Welche sequentiellen Sortiermethoden gibt es?

Empfohlenes Tutorial: Java-Tutorial

In Informatik und Mathematik ein Sortieralgorithmus (Englisch: Sortieralgorithmus) ist ein Algorithmus, der eine Reihe von Daten nach einer bestimmten Sortiermethode anordnen kann. In diesem Artikel werden mehrere häufig verwendete Sortieralgorithmen zusammengefasst, darunter Blasensortierung, Auswahlsortierung, Einfügungssortierung, Schnellsortierung und Zusammenführungssortierung.

1. Blasensortierung

Schematische Darstellung

Verstehen: Durch iteratives Durchlaufen der zu sortierenden Liste, Vergleichen jedes Paares benachbarter Elemente und Vertauschen, wenn sie in der falschen Reihenfolge sind.

Code:

public class BubbleSort {
  
    // logic to sort the elements
    public static void bubble_srt(int array[]) {        int n = array.length;        int k;        for (int m = n; m >= 0; m--) {            for (int i = 0; i < n - 1; i++) {
                k = i + 1;                if (array[i] > array[k]) {
                    swapNumbers(i, k, array);
                }
            }
            printNumbers(array);
        }
    }  
    private static void swapNumbers(int i, int j, int[] array) {  
        int temp;
        temp = array[i];        array[i] = array[j];        array[j] = temp;
    }  
    private static void printNumbers(int[] input) {          
        for (int i = 0; i < input.length; i++) {
            System.out.print(input[i] + ", ");
        }
        System.out.println("\n");
    }  
    public static void main(String[] args) {        int[] input = { 4, 2, 9, 6, 23, 12, 34, 0, 1 };
        bubble_srt(input);
    }
}

2. Auswahlsortierung

Prinzip Abbildung

Verstehen: Die innere Schleife findet den nächsten minimalen (oder maximalen) Wert und die äußere Schleife gibt den Wert ein Es ist der richtige Standort.

Code:

public class SelectionSort { 
    public static int[] doSelectionSort(int[] arr){         
        for (int i = 0; i < arr.length - 1; i++)
        {            int index = i;            for (int j = i + 1; j < arr.length; j++)                if (arr[j] < arr[index]) 
                    index = j;      
            int smallerNumber = arr[index];  
            arr[index] = arr[i];
            arr[i] = smallerNumber;
        }        return arr;
    }     
    public static void main(String a[]){         
        int[] arr1 = {10,34,2,56,7,67,88,42};        int[] arr2 = doSelectionSort(arr1);        for(int i:arr2){
            System.out.print(i);
            System.out.print(", ");
        }
    }
}

3. Einfügesortierung

Prinzip Abbildung

Verständnis: Jeder Schritt fügt einen zu sortierenden Datensatz in die zuvor sortierte Reihenfolge ein, bis alle Elemente eingefügt sind.

Code:

public class InsertionSort {
 
    public static void main(String a[]){        int[] arr1 = {10,34,2,56,7,67,88,42};        int[] arr2 = doInsertionSort(arr1);        for(int i:arr2){
            System.out.print(i);
            System.out.print(", ");
        }
    }
     
    public static int[] doInsertionSort(int[] input){         
        int temp;        for (int i = 1; i < input.length; i++) {            for(int j = i ; j > 0 ; j--){                if(input[j] < input[j-1]){
                    temp = input[j];                    input[j] = input[j-1];                    input[j-1] = temp;
                }
            }
        }        return input;
    }
}

4. Schnelle Sortierung

Schematische Darstellung

Verstehen: Zerlegen Sie das ursprüngliche Problem in mehrere Unterprobleme, die kleiner, aber in ihrer Struktur dem ursprünglichen Problem ähnlich sind, und lösen Sie diese Unterprobleme rekursiv lösen und dann die Lösungen dieser Unterprobleme zu einer Lösung des ursprünglichen Problems kombinieren.

Code:

public class QuickSort {
     
    private int array[];    private int length; 
    public void sort(int[] inputArr) {         
        if (inputArr == null || inputArr.length == 0) {            return;
        }        this.array = inputArr;
        length = inputArr.length;
        quickSort(0, length - 1);
    } 
    private void quickSort(int lowerIndex, int higherIndex) {         
        int i = lowerIndex;        int j = higherIndex;        // calculate pivot number, I am taking pivot as middle index number
        int pivot = array[lowerIndex+(higherIndex-lowerIndex)/2];        // Divide into two arrays
        while (i <= j) {            /**
             * In each iteration, we will identify a number from left side which 
             * is greater then the pivot value, and also we will identify a number 
             * from right side which is less then the pivot value. Once the search 
             * is done, then we exchange both numbers.
             */
            while (array[i] < pivot) {
                i++;
            }            while (array[j] > pivot) {
                j--;
            }            if (i <= j) {
                exchangeNumbers(i, j);                //move index to next position on both sides
                i++;
                j--;
            }
        }        // call quickSort() method recursively
        if (lowerIndex < j)
            quickSort(lowerIndex, j);        if (i < higherIndex)
            quickSort(i, higherIndex);
    } 
    private void exchangeNumbers(int i, int j) {        int temp = array[i];        array[i] = array[j];        array[j] = temp;
    }     
    public static void main(String a[]){
         
        MyQuickSort sorter = new MyQuickSort();        int[] input = {24,2,45,20,56,75,2,56,99,53,12};
        sorter.sort(input);        for(int i:input){
            System.out.print(i);
            System.out.print(" ");
        }
    }
}

5. Zusammenführungssortierung

Prinzip Abbildung

Verständnis: Teilen Sie die zu sortierende Sequenz in mehrere Teilsequenzen der Länge 1 und teilen Sie diese Sequenzen dann auf in zwei zusammenführen; mehrere geordnete Sequenzen der Länge 2 erhalten, dann mehrere geordnete Sequenzen der Länge 4 zusammenführen und sie dann paarweise zusammenführen;

Code:

public class MergeSort {
     
    private int[] array;    private int[] tempMergArr;    private int length; 
    public static void main(String a[]){         
        int[] inputArr = {45,23,11,89,77,98,4,28,65,43};
        MyMergeSort mms = new MyMergeSort();
        mms.sort(inputArr);        for(int i:inputArr){
            System.out.print(i);
            System.out.print(" ");
        }
    }     
    public void sort(int inputArr[]) {        this.array = inputArr;        this.length = inputArr.length;        this.tempMergArr = new int[length];
        doMergeSort(0, length - 1);
    } 
    private void doMergeSort(int lowerIndex, int higherIndex) {         
        if (lowerIndex < higherIndex) {            int middle = lowerIndex + (higherIndex - lowerIndex) / 2;            // Below step sorts the left side of the array
            doMergeSort(lowerIndex, middle);            // Below step sorts the right side of the array
            doMergeSort(middle + 1, higherIndex);            // Now merge both sides
            mergeParts(lowerIndex, middle, higherIndex);
        }
    } 
    private void mergeParts(int lowerIndex, int middle, int higherIndex) { 
        for (int i = lowerIndex; i <= higherIndex; i++) {
            tempMergArr[i] = array[i];
        }        int i = lowerIndex;        int j = middle + 1;        int k = lowerIndex;        while (i <= middle && j <= higherIndex) {            if (tempMergArr[i] <= tempMergArr[j]) {                array[k] = tempMergArr[i];
                i++;
            } else {                array[k] = tempMergArr[j];
                j++;
            }
            k++;
        }        while (i <= middle) {            array[k] = tempMergArr[i];
            k++;
            i++;
        }
    }
}

Das obige ist der detaillierte Inhalt vonWelche sequentiellen Sortiermethoden gibt es?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!