Une méthode d'apprentissage rapide simple et facile à comprendre pour le tri des bulles Java

Maîtrisez rapidement la manière la plus simple d'écrire un tri à bulles Java

Le tri à bulles est un algorithme de tri simple mais inefficace qui fait circuler la valeur maximale ou minimale non triée dans la séquence en échangeant à plusieurs reprises la fin ou le début des éléments adjacents. Cet article présentera l'un des moyens les plus simples d'écrire un tri à bulles en Java et fournira des exemples de code spécifiques.

L'idée de base du tri à bulles est de comparer deux éléments adjacents et d'échanger leurs positions s'ils sont dans le mauvais ordre, de sorte que chaque passe de tri fasse bouillonner le plus grand (ou le plus petit) élément jusqu'à la fin (ou le début) de la séquence ). Répétez ce processus jusqu'à ce que toute la séquence soit triée. Voici la manière la plus simple d'écrire un 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]) {
                    // 交换 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 : arr) {
            System.out.print(i + " ");
        }
    }
}

Dans l'exemple de code ci-dessus, nous définissons une classe BubbleSort, dans laquelle la méthode bubbleSort est utilisée pour implémenter le tri à bulles. logique de tri. Dans la méthode bubbleSort, nous utilisons une boucle à deux niveaux pour parcourir l'ensemble du tableau et effectuer des opérations de comparaison et d'échange. La boucle externe contrôle le nombre de passes de tri, et chaque passe fait remonter la valeur maximale non triée jusqu'à la fin de la séquence. La boucle interne contrôle les opérations de comparaison et d'échange de chaque passe, et trie en comparant deux éléments adjacents et en échangeant leurs positions. Après avoir terminé toutes les passes, les éléments du tableau seront triés par ordre croissant. BubbleSort 类，其中 bubbleSort 方法用于实现冒泡排序逻辑。在 bubbleSort 方法中，我们使用两层循环来遍历整个数组并进行比较和交换操作。外层循环控制排序的趟数，每一趟都会将未排序的最大值冒泡到序列的末尾。内层循环控制每一趟的比较和交换操作，通过比较相邻的两个元素并交换它们的位置来实现排序。在完成所有的趟数后，数组中的元素将按照升序排列。

在 main 方法中，我们创建了一个包含一些无序元素的数组，并将其传递给 bubbleSort

Dans la méthode main, nous créons un tableau avec quelques éléments non ordonnés et le transmettons à la méthode bubbleSort pour le tri. Enfin, nous générons les résultats triés en parcourant le tableau trié.

Grâce aux exemples de code ci-dessus, nous pouvons rapidement maîtriser la manière simple d'écrire le tri à bulles Java. Bien que le tri à bulles soit simple, il ne s'agit pas d'un algorithme de tri efficace. Sa complexité temporelle est O(n^2) et ses performances sont médiocres pour trier des données à grande échelle. Par conséquent, dans le développement réel, nous préférons utiliser d’autres algorithmes de tri plus efficaces, tels que le tri rapide, le tri par fusion, etc. 🎜

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!