排序算法总结

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序。如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。 

一、插入排序

(一)、直接插入排序

public class Sort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 51, 65, 6, 34, 67, 343, 56};
        int[] sortResult = insertionSort(arr);
        System.out.println(Arrays.toString(sortResult));
    }

    /**
     * 用一个临时变量存储待插入的值，从后往前找，如果找到比这个值大的元素，则将其前面的元素依次后移，
     * 结束后再将带插入的值放到该插入的位置，减去了许多不必要的交换操作
     * @param arr
     * @return
     */
    public static int[] insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            //待插入元素
            int insertValue = arr[i];
            int preIndex = i - 1;
            while (preIndex >= 0 && insertValue < arr[preIndex]) {
                arr[preIndex + 1] = arr[preIndex];
                preIndex--;
            }
            arr[preIndex + 1] = insertValue;
        }
        return arr;
    }
}

(二)、希尔排序（shell排序）

public class Sort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 51, 65, 6, 34, 67, 343, 56};
        int[] sortResult = shellSort(arr);
        System.out.println(Arrays.toString(sortResult));
    }

    /**
     * 希尔排序
     * 插入排序的升级版，设定步长为数组长度的一半，每次都除以二，直到步长为1
     * @param arr
     * @return
     */
    public static int[] shellSort(int[] arr) {
        int len = arr.length;
        for (int k = len / 2; k > 0; k /= 2) {
            for (int i = k; i < len; i++) {
                int temp = arr[i];
                int j = i - k;
                while (j >= 0 && temp < arr[j]) {
                    arr[j + k] = arr[j];
                    j -= k;
                }
                arr[j + k] = temp;
            }
        }
        return arr;
    }
}

二、选择排序

(一)、简单选择排序（直接排序）

public class Sort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 51, 65, 6, 34, 67, 343, 56};
        int[] sortResult = selectionSort(arr);
        System.out.println(Arrays.toString(sortResult));
    }

    /**
     * 遍历数组，每次遍历都找到最小的元素，记录其下标，内层循环结束后再根据下标将其与数组头部元素交换
     * 与冒泡排序不同的是，冒泡排序每次循环可能交换多次，而选择排序最多交换一次
     * @param arr 待排序数组
     * @return
     */
    public static int[] selectionSort(int[] arr) {
        int temp, minIndex;
        for (int i = 0; i < arr.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
        return arr;
    }
}

(二)、堆排序

public class HeapSort {

    public static void main(String[] args) {
        int[] arr = {1, 3, 51, 65, 6, 34, 67, 343, 56};
        int[] sortResult = heapSort(arr);
        System.out.println(Arrays.toString(sortResult));
    }

    public static int[] heapSort(int[] arr) {
        //以最后一个非叶子结点构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
        //此时顶部元素是最大的，交换顶部元素和末端元素
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            //末端元素已经是最大的了，无需考虑排序
            adjustHeap(arr, 0, i);
        }
        return arr;
    }

    /**
     * 形成大顶堆
     *
     * @param arr 数组元素
     * @param i   当前结点位置
     * @param len 结点个数
     */
    public static void adjustHeap(int[] arr, int i, int len) {
        //保存当前结点
        int temp = arr[i];
        //遍历当前结点的左子结点
        for (int k = 2 * i + 1; k < len; k = 2 * k + 1) {
            //如果右结点存在 且 右结点比左结点大，指向右结点
            if (k + 1 < len && arr[k] < arr[k + 1]) {
                k++;
            }
            //判断当前结点和左（右）结点哪个大
            if (temp < arr[k]) {
                //交换
                swap(arr, k, i);
                //交换后，下次遍历以该子结点作为根节点的子树就会受到影响，因此需要重新指定下次的根节点
                i = k;
            } else {
                //不用交换，直接终止循环
                break;
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

三、交换排序

(一)、冒泡排序

/**
 * 遍历数组，依次比较相邻的元素并交换，每次都将最大元素（根据正序还是逆序决定）放到数组末尾
 * @param arr 待排序数组
 * @return
 */
public static int[] bubbleSort(int[] arr) {
    int temp;

    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

冒泡排序优化一：

//冒泡排序：优化一
public static int[] bubbleSort1(int[] arr) {
    int temp;
    //记录数组是否有序
    boolean isSorted;

    for (int i = 0; i < arr.length - 1; i++) {
        isSorted = true;
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
                //记录本轮排序是否交换了元素，如果交换则置为false
                isSorted = false;
            }
        }
        //没有交换证明已经是有序的了，直接终止循环
        if (isSorted) {
            break;
        }
    }
    return arr;
}

冒泡排序优化二：

//冒泡排序：优化二
public static int[] bubbleSort2(int[] arr) {
    int temp;
    boolean isSorted;
    //第一次循环边界
    int sortBorder = arr.length - 1;
    //记录每轮排序最后一次进行交换的位置
    int lastSwapIndex = 0;

    for (int i = 0; i < arr.length - 1; i++) {
        isSorted = true;
        for (int j = 0; j < sortBorder; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
                isSorted = false;
                lastSwapIndex = j;
            }
        }
        sortBorder = lastSwapIndex;
        if (isSorted) {
            break;
        }
    }
    return arr;
}

(二)、快速排序

算法原理：先在数组中选择一个数字，通过一趟排序将要排序的数据分割成独立的两部分：比选择的数字小的数字都移到数组的左边，比选择的数字大的数字都移到数组的右边。然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序中基准的选取：
1. 第一个元素或最后一个元素，但是当数组中的元素原本为逆序时，升序排序就会变成一次只能确定基准元素的位置，无法发挥快排的优势
2. 随机选取
3. 三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。

举个栗子：

原数组：{3，7，2，9，1，4，6，8，10，5}
期望结果：{1，2，3，4，5，6，7，8，9，10}

快速排序示意图：

代码实现：

public class QuickSort {
    
    public static int divide(int[] a, int start, int end){
        //每次都以最右边的元素作为基准值
        int base = a[end];
        //start一旦等于end，就说明左右两个指针合并到了同一位置，可以结束此轮循环。
        while(start < end){
            while(start < end && a[start] <= base)
                //从左边开始遍历，如果比基准值小，就继续向右走
                start++;
            //上面的while循环结束时，就说明当前的a[start]的值比基准值大，应与基准值进行交换
            if(start < end){
                //交换
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
                //交换后，此时的那个被调换的值也同时调到了正确的位置(基准值右边)，因此右边也要同时向前移动一位
                end--;
            }    
            while(start < end && a[end] >= base)
                //从右边开始遍历，如果比基准值大，就继续向左走
                end--;
            //上面的while循环结束时，就说明当前的a[end]的值比基准值小，应与基准值进行交换
            if(start < end){
                //交换
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
                //交换后，此时的那个被调换的值也同时调到了正确的位置(基准值左边)，因此左边也要同时向后移动一位
                start++;
            }    
            
        }
        //这里返回start或者end皆可，此时的start和end都为基准值所在的位置
        return end;
    }
 
    /**
     * 排序
     * @param a
     * @param start
     * @param end
     */
    public static void sort(int[] a, int start, int end){
        if(start > end){ //start >= end ?
            //如果只有一个元素，就不用再排下去了
            return;
        } 
        else{
            //如果不止一个元素，继续划分两边递归排序下去
            int partition = divide(a, start, end);
            sort(a, start, partition-1);
            sort(a, partition+1, end);
        }
            
    }


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = new int[]{2,7,4,5,10,1,9,3,8,6};
        int[] b = new int[]{1,2,3,4,5,6,7,8,9,10};
        int[] c = new int[]{10,9,8,7,6,5,4,3,2,1};
        int[] d = new int[]{1,10,2,9,3,2,4,7,5,6};
        int[] e = {3};
            
        sort(b, 0, b.length-1);
            
        System.out.println("排序后的结果：");
        for(int x : b){
            System.out.print(x+" ");
        }

    }

}

四、归并排序

public class Sort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 51, 65, 6, 34, 67, 343, 56};
        int[] sortResult = mergeSort(arr);
        System.out.println(Arrays.toString(sortResult));
    }

    //归并排序
    public static int[] mergeSort(int[] arr) {
        return mergeSort(arr, 0, arr.length - 1, new int[arr.length]);
    }

    /**
     * 归并排序通过递归将数组分解为只有两个元素，按照它们的大小放入到一个临时数组中，直到全部合并
     *
     * @param arr   待排序数组
     * @param left  左索引
     * @param right 右索引
     * @param temp  临时数组，存储每次合并后的元素
     * @return
     */
    public static int[] mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) >> 1;
            //向左分解
            mergeSort(arr, left, mid, temp);
            //向右分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);
        }
        return arr;
    }

    //合并
    public static int[] merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left, j = mid + 1, k = 0;
        //按大小放入临时数组中
        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[k] = arr[i];
                k++;
                i++;
            } else {
                temp[k] = arr[j];
                k++;
                j++;
            }
        }

        //将剩余元素放到temp剩余位置
        while (i <= mid) {
            temp[k] = arr[i];
            k++;
            i++;
        }
        while (j <= right) {
            temp[k] = arr[j];
            k++;
            j++;
        }

        //将排好序的temp数组元素赋值给原数组
        k = 0;
        int l = left;
        while (l <= right) {
            arr[l] = temp[k];
            k++;
            l++;
        }

        return arr;
    }

}

五、基数排序

public class RadixSort {

    public static void main(String[] args) {
        int[] arr = {1, 3, 51, 65, 6, 34, 67, 343, 56};
        int[] sortResult = radixSort(arr);
        System.out.println(Arrays.toString(sortResult));
    }

    /**
     * 基数排序：
     * 根据每个数的个位、十位、百位...的值（0~9）放入桶中（规则和计数排序相同），因此需要10个桶
     *
     * @param arr
     * @return
     */
    public static int[] radixSort(int[] arr) {
        //创建并初始化10个桶
        ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            bucketList.add(new LinkedList<>());
        }

        //找出数据中最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }

        //获取最大值的位数
        int maxRadix = (max + "").length();
        //从个位开始
        for (int i = 0; i < maxRadix; i++) {
            //将待排序元素放入桶中
            for (int j = 0; j < arr.length; j++) {
                //获取数字对应位上的值
                int radix = arr[j] / (int) Math.pow(10, i) % 10;
                //放入对应的桶中
                bucketList.get(radix).add(arr[j]);
            }
            //将桶中元素放回原数组
            int k = 0;
            for (int j = 0; j < 10; j++) {
                for (Integer number : bucketList.get(j)) {
                    arr[k++] = number;
                }
                bucketList.get(j).clear();
            }
        }
        return arr;
    }
}

 另：排序算法的稳定性

1. 稳定性的定义
假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

举个栗子：以{6，2，4，6，1｝为例

a[0]	a[1]	a[2]	a[3]	a[4]
6	2	4	6	1

有两个6，a[0]和a[3]。排序结果就有两种可能：

1	2	4	6	6
原a[4]	原a[1]	原a[2]	原a[0]	原a[3]
原a[4]	原a[1]	原a[2]	原a[3]	原a[0]

如果排序结束后，a[0]可以保证一定在a[3]前头，也就是他们原有的顺序不变，那这种排序算法就是稳定的。反之，如果不能保证原有顺序，这种算法就是不稳定的。

2. 常见算法的稳定性
堆排序、快速排序、希尔排序、直接选择排序不是稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。

3. 稳定性的意义
1、如果只是简单的进行数字的排序，那么稳定性将毫无意义。
2、如果排序的内容仅仅是一个复杂对象的某一个数字属性，那么稳定性依旧将毫无意义（所谓的交换操作的开销已经算在算法的开销内了，如果嫌弃这种开销，不如换算法好了？）
3、如果要排序的内容是一个复杂对象的多个数字属性，但是其原本的初始顺序毫无意义，那么稳定性依旧将毫无意义。
4、除非要排序的内容是一个复杂对象的多个数字属性，且其原本的初始顺序存在意义，那么我们需要在二次排序的基础上保持原有排序的意义，才需要使用到稳定性的算法。例如要排序的内容是一组原本按照价格高低排序的对象，如今需要按照销量高低排序，使用稳定性算法，可以使得想同销量的对象依旧保持着价格高低的排序展现，只有销量不同的才会重新排序。（当然，如果需求不需要保持初始的排序意义，那么使用稳定性算法依旧将毫无意义）。

参考：

https://www.cnblogs.com/songjilong/p/12234856.html

https://blog.csdn.net/sunxianghuang/article/details/51872360

https://blog.csdn.net/it_zjyang/article/details/53406764

https://www.cnblogs.com/hydor/p/3530593.html

https://blog.csdn.net/chenliguan/article/details/53037482