Une analyse approfondie de l'implémentation la plus concise du tri à bulles en Java

Explication détaillée de la manière la plus simple d'écrire un tri à bulles Java

Le tri à bulles est un algorithme de tri de base. Il implémente le tri en comparant et en échangeant des éléments adjacents. Les éléments plus grands (ou plus petits) seront triés une fois vers le haut (ou vers le bas). ) dans la bonne position. Cet article expliquera en détail la manière la plus simple 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 les éléments adjacents de gauche à droite, et si l'élément précédent est supérieur (ou inférieur) au dernier élément, d'échanger leurs positions. Après un tel cycle de comparaison et d'échange, l'élément le plus grand (ou le plus petit) « bouillonnera » vers l'extrême droite (ou l'extrême gauche). Effectuez ensuite la même opération sur les éléments restants jusqu'à ce que tous les éléments soient triés.

Ce qui suit est la manière la plus simple d'écrire un tri à bulles en Java :

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; 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 = {5, 2, 8, 7, 1, 3, 9, 4, 6};
        bubbleSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Dans le code ci-dessus, nous définissons d'abord une méthode bubbleSort, qui reçoit un tableau d'entiers en paramètre. Dans cette méthode, nous utilisons deux boucles for imbriquées, la boucle externe contrôle le nombre de tours et la boucle interne contrôle la comparaison et l'échange à chaque tour. bubbleSort方法，该方法接收一个整型数组作为参数。在该方法中，我们使用两个嵌套的for循环，外层循环控制轮数，内层循环控制每一轮中的比较和交换。

内层循环的初始值是len - 1 - i，其中len是数组的长度，i是当前轮数。这是因为每一轮都会有一个元素移动到正确的位置，所以每一轮结束后，需要比较和交换的元素数量会减少。

在内层循环中，我们使用arr[j]和arr[j + 1]进行比较，如果arr[j]大于arr[j + 1]，则交换它们的位置。交换使用一个临时变量temp来暂存arr[j]的值，然后将arr[j + 1]的值赋给arr[j]，最后将temp的值赋给arr[j + 1]，完成交换。

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

La valeur initiale de la boucle interne est len - 1 - i, où len est la longueur du tableau et i est l'actuel numéro rond. En effet, à chaque tour, un élément est déplacé vers la bonne position, donc après chaque tour, il y a moins d'éléments à comparer et à échanger.

Dans la boucle interne, nous utilisons arr[j] et arr[j + 1] pour comparaison, si arr[j] Plus grand que arr[j + 1], leurs positions sont inversées. Exchange utilise une variable temporaire temp pour stocker temporairement la valeur de arr[j], puis attribue la valeur de arr[j + 1] à arr[j], et enfin attribuer la valeur de temp à arr[j + 1] pour terminer l'échange.

Dans la méthode main, nous créons un tableau contenant 9 entiers et appelons la méthode bubbleSort pour trier le tableau. Enfin, parcourez le tableau via une boucle for et imprimez chaque élément. 🎜🎜En exécutant le code ci-dessus, nous pouvons obtenir le résultat suivant : 🎜

1 2 3 4 5 6 7 8 9

🎜Ce qui précède est le moyen le plus simple d'écrire un tri à bulles en Java et des exemples de code spécifiques. Bien que le tri à bulles soit simple, il est moins efficace dans les applications pratiques. Par conséquent, lors du traitement de données à grande échelle, vous devriez envisager d'utiliser un algorithme de tri plus efficace. 🎜

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!