常用排序算法及Java实现

概述

在计算器科学与数学中，一个排序算法（英语：sorting algorithm）是一种能将一串数据依照特定排序方式进行排列的一种算法。本文将总结几类常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序。

---

算法原理及实现

1、冒泡排序

• 原理图

• 理解

通过重复地遍历要排序的列表，比较每对相邻的项目，并在顺序错误的情况下交换它们。

• java 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、选择排序

• 原理图

• 理解

内部循环查找下一个最小（或最大）值，外部循环将该值放入其适当的位置。

• java 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、插入排序

• 原理图

• 理解

每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

• java 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、快速排序

• 原理图

• 理解

将原问题分解为若干个规模更小，但结构与原问题相似的子问题，递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

• java 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、归并排序

• 原理图

• 理解

将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直接合并成一个数列为止。

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

---

参考链接

java sorting algorithms