排序及其分类

什么是排序

排序（sorting）的功能是将一个数据元素的任意序列，重写排列成一个按关键字有序的序列。其确切的定义为：假设有n个数据元素的序列（R1，R2.，。。。，Rn），其相应关键字的序列是（K1，K2，。。。，Kn）。通过排序要求找出下标1，2，。。。，n的一种排列p1，p2，。。。，pn，使得相应关键字满足如下的非递减（或非递增）关系Kp 1<= Kp 2 <=…<= Kp n这样，就得到一个按关键字有序的记录序列：（Rp1，Rp2，。。。，Rpn）

内部排序和外部排序

一类是整个排序过程在内存储器中进行，称为内部排序；另一类是由于带排序元素数量台打，以至于内存储器无法容纳全部数据，排序需要借助外存储设备才能完成，这类排序称为外部排序。以下介绍的都是内部排序

稳定排序和不稳定排序

如果在待排序的序列中存在多个具有相同关键字的元素，假设Ki = Kj（1<=i<=n,1<=j<=n,i != j),若在排序之前的序列中Ri在Rj之前，经过排序后得到的序列中Ri仍然在Rj之前，则称所用的排序方法是稳定的；否则，当相同关键字元素的前后关系在排序中发生编号，则称所用的排序方法是不稳定的。
无论是稳定的还是不稳定的排序方法，均能完成排序的功能。在某些场合可能对排序有稳定性的要求，此时就应当选择稳定的排序方法。例如假设一组学生记录已经按照学号有序，现在需要根据学生的成绩排序，当分数相同时要求学号小的学生在前，显然此时对分数进行排序就必须选择稳定的排序方法。
排序前（56，34，47，23，66，18，82，47）
若排序后得到结果（18，23，34，47，47，56，66，82），则称该排序方法是稳定的
若排序后得到结果（18，23，34，47，47，56，66，82），则称该排序方法是不稳定的

比较排序和非比较排序

大部分排序都是需要通过比较来判断大小，作为排序的依据的。但是也有例外的，避暑计数排序、基数排序、不需要进行比较。
插入排序：将无需子列中的一个过几个记录“插入”到有序序列中，从而增加记录的有序子序列的长度
交换排序：通过“交换”无序序列中的记录从而得到其中关键字最小或最大的记录，并将它加入到有序子序列中国，以此方法增加记录的有序子序列长度。
选择排序：从记录的无序子序列中“选择”关键字最小或最大的记录，并将它加入到有序子序列中，以此方法增加记录的有序子序列的长度。
归并排序：通过”归并“两个或两个以上的记录有序子序列，逐步增加记录有序序列的长度

排序类型

一般说是八大排序类型
另外还可以加上非比较的计数排序、选择排序中的树形选择排序、插入排序中的折半插入排序

排序效率

时间复杂度最高的就是三种 基本排序：直接插入、简单选择、冒泡排序。
建议优先掌握直接擦汗如、简单选择、冒泡排序、快速排序

快速排序

快速排序是冒泡排序的改进版，也是最好的一种内排序，还涉及到分治和递归，子啊很多面试题中都会出现，也是作为程序员必须掌握的一种排序方法。

冒泡排序纵记录的比较和交换是在相邻的单元中进行，每次交换只能上移或者下移一个单元，因而总的比较和移动次数较多。

public class MaoPao {
    public static void main(String[] args) {
        int[] a = new int[]{1, 4, 6, 2, 7, 5, 6, 3, 11, 47, 83, 1, 5};
        for (int i = 1; i < a.length; i++) {
            for (int j = 0; j < a.length - i; j++) {
                if (a[j] > a[j + 1]) {
                    int t = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = t;
                }
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

快速排序C.R.A.Hoare于1962年提出的一种划分交换排序，它采用了一种分治的策略，通常程其为分治法（Divide-and-ConquerMethod).该方法的基本思想是：

1. 先从数量中取出一个数作为基准数（简单起见可以取第一个数）
2. 分区过程，将比这个数大的数全放到他的右边，小于或者等于他的数放到左边（分区）
3. 再对左右区间城府第一步、第二部，直到各区间只有一个数.（递归）
   快速排序=冒泡+分治+递归
   快速排序的过程：东拆西补，或西拆东补，一边拆一边补

package DataStructure.Sort;

import java.util.Arrays;

/**
 * @Description TODO
 * @Author Matthew
 * @Date 2019/6/8 18:42
 * @Version 1.0
 */

public class QuickSort {
    public static void main(String[] args) {
        //给出无序数组
        int[] array = {72, 6, 57, 88, 60, 42, 83, 73, 48, 85};
        //输出无序数组
        System.out.println(Arrays.toString(array));
        //快速排序
        quickSort(array);
        //输出有序数组
        System.out.println(Arrays.toString(array));
    }

    public static void quickSort(int[] array) {
        int low = 0;
        int high = array.length - 1;
        quickSort(array, low, high);
    }

    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {//如果low<high结束
            //分区操作，将一个数组分成两个分区，返回分区界限索引
            int index = partition(array, low, high);
            //对左分区进行快排
            quickSort(array,low,index-1);
            //对右分区进行快排
            quickSort(array, index + 1, high);
        }
    }

    private static int partition(int[] array, int low, int high) {
        //指定左指针i和右指针j
        int i = low;
        int j = high;
        //将第一个数作为基准值，挖坑
        int x = array[i];
        //使用循环实现分区操作
        while (i != j) {
            //从右向左移动j，找到小于基准值的值
            while (x <= array[j] && i < j) {
                j--;
            }
            //将右侧找到小于基准数的值加入到i的坑中，左指针i++,向中间移动一个位置
            if (i < j) {
                array[i] = array[j];
                i++;
            }

            //从左往右移动j，找到大于基准值的值
            while (x >= array[i] && i < j) {
                i++;
            }
            //将左侧找到大于等于基准数的值加入到j的坑中，右指针j--，向中间移动一个位置
            if (i < j) {
                array[j] = array[i];
                j--;
            }
        }
        //使用基准值填坑，这就是基准值的最终位置
        array[i] = x;//array[j]=x
        //返回基准值的位置
        return i;//return j
    }
}

快速排序算法的分析

1. 当分区选取的基准元素为待排序元素中的最大或最小值时，为最坏的情况，时间复杂度和直接插入排序的一样，移动次数达到最大值，Cmax = 1+2+。。。+（n-1）=n*（n-1）/2=O（n2）此时最好时间复杂度为O（n2）
2. 当分区选取的基准元素为待排序元素中的中值为最好情况，时间复杂度为O（nlog2 n）。
3. 快速排序的空间复杂度为O（log2 n）
4. 当待排序元素类似（6，1，3，7，3）且基准元素为6时，经过分区，形成(1,3,3,6,7)两个3的相对位置发生了改变，所以快速排序时一种不稳定排序。