Java排序算法

（1）快速排序

在一个待排序的序列中，设置两个标记位，一个代表开始位(start)（从0开始），一个代表结束位(end)（数组的长度-1）。再设置两个变量，分别代表低位的数(low)和高位的数(high)，然后选定一个标准数(standard)初始时standard = array[start]，以这个数为标准，从结束位开始往左查找（low和high比喻成指针），如果array[high]比标准数大，则继续往左移动即high--，如果比标准数小，则用右边指针对应的数替换左边指针对应位置的数，替换后左边指针开始与标准数比较，如果array[low]比标准数小，则向右移动，即low++，如果比标准数大，则用左边指针对应的数替换右边指针对应位置的数，替换右边指针开始活跃，如此循环，直到两个指针重合，此时，把标准数放到两个指针重合的位置，这样就把比标准数小的数放到了标准数左边，比标准数大的数就放到了标准数右边。然后，把标准数赋值给low或者high，此时左边的序列的开始位为start，结束位为low或者high，右边的序列的开始位为high + 1，结束位为end。以此重复上述的步骤形成递归。

图解

快速排序

代码

package sort;

import java.util.Arrays;

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {12,3,43,7,5,56,4,5,9};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序结果为：" + Arrays.toString(arr));
    }
    
    public static void quickSort(int[] arr,int start,int end) {
        if (start < end) {//循环条件
            //把序列中第0个数字作为标准数
            int standard = arr[start];
            //记录需要排序的下标
            int low = start;
            int high = end;
            //循环找出比标准数大的数和比标准数小的数
            while(low < high) {
                //右边的数字比标准数大
                while(low < high && arr[high] >= standard) {
                    high--;
                }
                //当右边的数比标准数小，用右边的数替换左边的数
                arr[low] = arr[high];
                //如果左边的数字比标准数小
                while (low < high && arr[low] <= standard) {
                    low++;
                }
                //当左边的数字比标准数大，用左边的数字替换右边的数字
                arr[high] = arr[low];
            }
            //当low和high重合时，把标准数赋值给low或者high
            arr[low] = standard;
            //此时序列分两部分，左边为小的数，右边为大的数。
            //处理所有小的数字
            quickSort(arr, start, low);
            //处理所有大的数字
            quickSort(arr, low + 1, end);
        }
    }
}

（2）冒泡排序

序列中的元素两两排序，选出大的元素放到后面即与小的元素交换位置，在剩下的序列中再两两排序，重复这个步骤。两层for循环控制，外层控制轮数，轮数为数组长度-1，内层循环控制比较次数，比较次数为数组长度-轮数，如果i从0开始，还要减1，即是数组长度-轮数-1，如果i从1开始，就数组长度-轮数。

图解

冒泡排序

代码

package sort;

import java.util.Arrays;

public class BubbleSort {
    
    public void bubbleSort(int[] arr) {
        int length = arr.length;
        int temp;
        for(int i=0; iarr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int[] a = {63,35,3,9,39,43,0,24,1};
        BubbleSort bSort = new BubbleSort();
        bSort.bubbleSort(a);
        System.out.println("排序结果为：" + Arrays.toString(a));
    }
}

（3）直接插入排序

从已经排好序的序列中插入数字，在一个待排序的序列中，默认第一个数字就是一个排好序的序列，然后遍历除了第一个数字的之外的数字，所以for循环中的i = 1，要插入的数为insertNum = i，已经排好序的序列从j = i - 1这个位置开始遍历比较，序列从后到前循环，将大于insertNum的数向后移动一格。当insertNum大于与之相比的数时，insertNum插入到与之比较的数前面。

图解

插入排序

代码

package sort;

import java.util.Arrays;

public class InsertSort {

    public static void main(String[] args) {
        int[] arr = {2,32,3,5,4,1,9,12};
        insertSort(arr);
        System.out.println("排序结果为：" + Arrays.toString(arr));
    }
    public static void insertSort(int[] arr) {
        //遍历所有数字，第一个除外
        for (int i = 1; i < arr.length; i++) {
            int insertNum = arr[i];//要插入的数字
            int j = i-1;//已经排好序的序列长度
            //序列从后到前循环，将大于insertNum的数向后移动一格
            while (j>=0 && insertNum < arr[j]) {
                arr[j+1] = arr[j];//元素向后移动一位
                j--;//往回遍历
            }
            //当insertNum大于与之相比的数时，insertNum插入到与之比较的数前面即arr[j+1]
            arr[j+1] = insertNum;
        }
    }
}

（4）简单选择排序

遍历整个序列选出最小的数放在最前面，然后遍历剩下的序列，将最小的数放在最前面，重复这个步骤。记住当前位置的数字和位置，初始时默认记住第一个数，然后遍历当前位置之后的序列，选出比当前位置小的数，并记住其值和位置，然后和之前记住的数交换位置。

图解

简单选择排序

代码

package sort;

import java.util.Arrays;

public class SelectSort {

    public static void main(String[] args) {
        int[] a = {25,3,9,6,1,0,12,8};
        selectSort(a);
        System.out.println("排序结果为：" + Arrays.toString(a));
    }
    public static void selectSort(int[] a) {
        //遍历所有数字
        for (int i = 0; i < a.length; i++) {
            int key = a[i];//记住当前的数字
            int position = i;//记住当前位置
            //遍历当前位置后面所有的数字，并与当前数字进行比较
            for (int j = i + 1; j < a.length; j++) {
                if (key > a[j]) {
                    key = a[j];//小的数赋值给key
                    position = j;//记住小数的位置
                }
            }
            //与小的数交换位置
            a[position] = a[i];
            a[i] = key;
        }
    }
}

（5）希尔排序

希尔排序也属于插入排序，相比于直接插入排序，排序速度更快，用于处理数据量大时。
步骤：
1、设数组的元素个数为n，用n/2得到一个数k，k作为步数或者叫增量。从第一个数开始将下标差值为k的数分为一组，然后把分好组的序列进行插入排序使它们构成有序序列。
2、排完一轮后，再将上一轮得到的k/2，从第一个数开始将下标差值为k的数分为一组，然后把分好组的序列进行插入排序使它们构成有序序列。
3、重复第二个步骤直到k=0。

图解

希尔排序

代码

package sort;

import java.util.Arrays;

public class ShellSort {

    public static void main(String[] args) {
        int[] a = {2,1,5,7,8,9,0};
        shellSort(a);
        System.out.println("排序结果为：" + Arrays.toString(a));
    }

    public static void shellSort(int[] a) {
        //遍历所有的步长
        for (int d = a.length/2; d > 0; d/=2) {
            //根据步长遍历所有的元素
            for (int i = d; i < a.length; i++) {
                //遍历本组的所有元素
                for (int j = i - d; j >= 0; j-=d) {
                    //如果当前元素大于加上步长后的那个元素
                    if (a[j] > a[j+d]) {
                        int temp = a[j];
                        a[j] = a[j+d];
                        a[j+d] = temp;
                    }
                }
            }
        }
    }
}