Home  >  Article  >  Java  >  What are the sequential sorting methods?

What are the sequential sorting methods?

angryTom
angryTomOriginal
2019-07-23 14:54:1912529browse

What are the sequential sorting methods?

Recommended tutorial: java tutorial

In computer science and mathematics, a Sorting algorithm (English: Sorting algorithm) is an algorithm that can arrange a series of data according to a specific sorting method. This article will summarize several commonly used sorting algorithms, including bubble sort, selection sort, insertion sort, quick sort and merge sort.

1. Bubble sort

Principle diagram

What are the sequential sorting methods?

Understanding: By repeatedly iterating through the list to be sorted, comparing each pair of adjacent items, and swapping them if they are in the wrong order.

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. Selection sort

Principle Figure

What are the sequential sorting methods?

Understanding: The inner loop finds the next minimum (or maximum) value, and the outer loop puts the value into its proper location.

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. Insertion sort

Principle Figure

What are the sequential sorting methods?

Understanding: Each step inserts a record to be sorted into the previously sorted sequence. Until all elements are inserted.

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. Quick sort

Schematic diagram

What are the sequential sorting methods?

Understanding: Decompose the original problem into several smaller sub-problems but similar structures to the original problem, and solve these sub-problems recursively. problem, and then combine the solutions to these sub-problems into a solution to the original problem.

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. Merge sort

Principle Figure

What are the sequential sorting methods?

Understanding:Divide the sequence to be sorted into several sub-sequences with a length of 1, and then divide these sequences into two Merge two; obtain several ordered sequence of length 2, and then merge these sequence two by two; obtain several ordered sequence of length 4, and then merge them two by two; until directly merged into one sequence.

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++;
        }
    }
}

The above is the detailed content of What are the sequential sorting methods?. For more information, please follow other related articles on the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Previous article:Summary of return usageNext article:Summary of return usage