Java écrit un algorithme de tri par insertion et affiche les résultats

Exemple de code et résultats d'exécution de l'implémentation Java du tri par insertion

Le tri par insertion est un algorithme de tri simple et couramment utilisé qui est largement utilisé dans les applications pratiques. Cet article explique comment utiliser le langage Java pour implémenter le tri par insertion et donne des exemples de code correspondants et les résultats d'exécution.

L'idée de base du tri par insertion est de diviser le tableau à trier en deux parties, triées et non triées. Initialement, la partie triée ne comporte qu'un seul élément, puis les éléments de la partie non triée sont insérés aux positions appropriées. de la pièce triée dans l'ordre jusqu'à ce que tous les éléments soient insérés.

Ce qui suit est un exemple de code pour implémenter le tri par insertion en Java :

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j -= 1;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 10, 8, 3};
        System.out.println("排序前：");
        printArray(arr);
        insertionSort(arr);
        System.out.println("排序后：");
        printArray(arr);
    }

    public static void printArray(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

La méthode insertionSort dans le code implémente l'algorithme de tri par insertion. Il utilise une boucle externe pour parcourir chaque élément de la partie non triée, en insérant l'élément dans la position appropriée dans la partie triée. La boucle interne recherche une position d'insertion appropriée dans la partie triée et déplace les éléments plus grands que l'élément actuel vers l'arrière. insertionSort方法实现了插入排序算法。它使用一个外层循环遍历未排序部分的每个元素，将元素插入到已排序部分的合适位置。内层循环则是在已排序部分中寻找合适的插入位置，将比当前元素大的元素往后移动。

在main方法中，我们定义了一个整型数组arr，初始化了一组无序的元素。首先输出了排序前的数组，然后调用insertionSort

Dans la méthode main, nous définissons un tableau d'entiers arr et initialisons un ensemble d'éléments non ordonnés. Tout d'abord, le tableau avant le tri est affiché, puis la méthode insertionSort est appelée pour trier, et enfin le tableau trié est affiché.

Les résultats d'exécution sont les suivants :

排序前：
5 2 10 8 3 
排序后：
2 3 5 8 10 

Vous pouvez voir qu'après le traitement par l'algorithme de tri par insertion, le tableau non ordonné d'origine a été trié avec succès du plus petit au plus grand.

La complexité temporelle du tri par insertion est O(n^2) et ses performances sont meilleures lors du traitement d'ensembles de données à petite échelle. Cependant, pour les ensembles de données à grande échelle, les performances du tri par insertion diminueront considérablement et ne seront pas aussi bonnes que celles d’autres algorithmes de tri efficaces. Par conséquent, dans le développement réel, il est nécessaire de choisir un algorithme de tri approprié en fonction de la situation spécifique. 🎜

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!