Implémentation du tri à bulles Java classique

Méthode d'implémentation classique du tri à bulles Java

L'algorithme de tri à bulles est un algorithme de tri simple et couramment utilisé qui est souvent utilisé dans le développement réel. Son idée de base est de partir de la position de départ de la séquence d'éléments à trier et de comparer les tailles de deux éléments adjacents en séquence. Si l'ordre est incorrect, échangez-les jusqu'à ce que la séquence entière soit ordonnée. Ce qui suit présentera la méthode d'implémentation spécifique du tri à bulles et joindra des exemples de code Java.

Le cœur de l'algorithme de tri des bulles est d'atteindre l'objectif de tri en comparant constamment les tailles des éléments adjacents et en les échangeant selon les besoins. Le déroulement de l'algorithme est le suivant :

1. Parcourez la séquence d'éléments à trier et comparez l'élément actuel avec son élément suivant.
2. Si l'élément actuel est supérieur à l'élément suivant, échangez les positions des deux éléments.
3. Répétez les opérations ci-dessus jusqu'à ce que toute la séquence soit en ordre.

Ce qui suit est un exemple de code utilisant le langage Java pour implémenter l'algorithme de tri à bulles :

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻元素的位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
        bubbleSort(arr);
        System.out.println("排序后的数组：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

Dans le code ci-dessus, la méthode bubbleSort est utilisée pour implémenter l'algorithme de tri à bulles. Tout d’abord, nous utilisons deux boucles imbriquées pour parcourir le tableau à trier. La boucle externe contrôle le nombre de tours de parcours et la boucle interne contrôle la comparaison et l'échange de chaque tour. En comparant les tailles des éléments adjacents, si l'ordre est incorrect, une opération d'échange est effectuée. Enfin, lorsque tous les éléments sont disposés dans l’ordre, le tri est terminé. bubbleSort方法用于实现冒泡排序算法。首先，我们使用两个嵌套的循环来遍历待排序数组。外层循环控制遍历的轮数，内层循环控制每一轮的比较和交换。通过比较相邻元素的大小，若顺序不正确，则进行交换操作。最终，当所有的元素都有序排列时，排序完成。

在main方法中，我们创建了一个包含一些整数的数组，并调用bubbleSort

Dans la méthode main, nous créons un tableau contenant des entiers et appelons la méthode bubbleSort pour le trier. Enfin, nous affichons le tableau trié sur la console.

La complexité temporelle de l'algorithme de tri à bulles est O(n^2), où n est la longueur du tableau à trier. Bien que les performances de l’algorithme de tri à bulles soient médiocres, car sa mise en œuvre est simple et intuitive, il présente néanmoins une certaine praticité pour le tri de données à petite échelle.

Pour résumer, l'algorithme de tri à bulles est un algorithme de tri simple et couramment utilisé. En comparant constamment les tailles des éléments adjacents et en effectuant des opérations d'échange, la séquence entière peut être progressivement ordonnée. Dans le développement réel, nous pouvons utiliser le langage Java pour implémenter l'algorithme de tri à bulles. Grâce à l'explication et à la démonstration d'exemples de code, nous espérons que les lecteurs pourront mieux comprendre et maîtriser cet algorithme de tri classique. 🎜

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!