Développement Java : comment implémenter des structures de données et des algorithmes

Développement Java : Comment implémenter des structures de données et des algorithmes, des exemples de code spécifiques sont requis

Introduction : Les structures de données et les algorithmes sont des connaissances de base importantes en informatique et sont des compétences que tout développeur Java doit maîtriser. Cet article présentera comment implémenter des structures de données et des algorithmes courants en Java et donnera des exemples de code spécifiques.

1. Implémentation de la structure de données

1. Array

Array est l'une des structures de données les plus simples Vous pouvez utiliser le code suivant pour créer un tableau d'entiers en Java :

int[] array = new int[5];

2. LinkedList

Une liste chaînée est. une structure de données dynamique. Vous pouvez utiliser le code suivant pour implémenter une liste chaînée unidirectionnelle en Java :

class Node {
    int value;
    Node next;
    
    public Node(int value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    Node head;
    
    public void add(int value) {
        Node newNode = new Node(value);
        
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
}

3. Stack (Stack)

La pile est une structure de données dernier entré, premier sorti (LIFO). Vous pouvez utiliser ce qui suit Le code implémente une pile :

class Stack {
    int[] array;
    int top;
    
    public Stack(int size) {
        array = new int[size];
        top = -1;
    }
    
    public void push(int value) {
        if (top < array.length - 1) {
            array[++top] = value;
        }
    }
    
    public int pop() {
        if (top >= 0) {
            return array[top--];
        }
        return -1;
    }
}

2. Implémentation d'algorithmes courants

1. Algorithme de tri

(1) Tri à bulles

Le tri à bulles est un algorithme de tri simple qui a été visité à plusieurs reprises Éléments à triés, les éléments adjacents sont comparés et les positions sont échangées jusqu'à ce qu'aucun échange ne se produise.

Ce qui suit est un exemple de code d'utilisation de Java pour implémenter le tri à bulles :

public void bubbleSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

(2) Tri rapide (Tri rapide)

Le tri rapide est un algorithme de tri couramment utilisé qui divise une séquence en deux parties en sélectionnant un élément de base. , puis triez les deux parties séparément.

Ce qui suit est un exemple de code pour implémenter le tri rapide à l'aide de Java :

public void quickSort(int[] array, int left, int right) {
    if (left < right) {
        int pivot = partition(array, left, right);
        quickSort(array, left, pivot - 1);
        quickSort(array, pivot + 1, right);
    }
}

public int partition(int[] array, int left, int right) {
    int pivot = array[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (array[j] < pivot) {
            i++;
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    int temp = array[i + 1];
    array[i + 1] = array[right];
    array[right] = temp;
    return i + 1;
}

2. Algorithme de recherche

(1) Recherche binaire (Recherche binaire)

La recherche binaire est un algorithme de recherche courant qui recherche dans un tableau ordonné Spécifie le position de l'élément.

Ce qui suit est un exemple de code pour implémenter la recherche binaire à l'aide de Java :

public int binarySearch(int[] array, int target) {
    int left = 0;
    int right = array.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (array[mid] == target) {
            return mid;
        } else if (array[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

(2) Recherche linéaire (recherche linéaire)

La recherche linéaire est un algorithme de recherche simple qui compare les éléments d'un tableau un par un jusqu'à ce que l'élément cible soit trouvé ou parcourir l’ensemble du tableau.

Ce qui suit est un exemple de code d'utilisation de Java pour implémenter la recherche linéaire :

public int linearSearch(int[] array, int target) {
    for (int i = 0; i < array.length; i++) {
        if (array[i] == target) {
            return i;
        }
    }
    return -1;
}

Conclusion :

Grâce à l'introduction de cet article, nous avons appris comment implémenter des structures de données et des algorithmes courants en Java, et donné des exemples de code spécifiques. Nous espérons que les lecteurs pourront mieux comprendre et maîtriser ces connaissances par la pratique et améliorer leurs capacités de programmation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!