稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度：一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。

0.3 算法总结

算法总结图片名词解释：
n: 数据规模
k: “桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

0.4 算法分类

算法分类

0.5 比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logn次，所以时间复杂度平均O(nlogn)。比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

1、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

1.2 动图演示

在这里插入图片描述

1.3 代码实现

冒泡排序需要两个嵌套的循环. 其中, 外层循环移动游标; 内层循环遍历游标及之后(或之前)的元素, 通过两两交换的方式, 每次只确保该内循环结束位置排序正确, 然后内层循环周期结束, 交由外层循环往后(或前)移动游标, 随即开始下一轮内层循环, 以此类推, 直至循环结束.

public static void bobbleSort(int[] arr){
        if(arr==null || arr.length<2){
            return;
        }
        // 外层循环控制比较轮数i
        for(int i=arr.length-1;i>0;i--){
        	// 内层循环控制每一轮比较次数，每进行一轮排序都会找出一个较大值
            for(int j=0;j<i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }
    public static void swap(int[] arr,int x,int y){
        int temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }

1.4 算法分析

最佳情况： $T(n) = O(n)$ 最差情况: $T(n) = O(n^2)$ 平均情况： $T(n) = O(n^2)$

2、选择排序

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1…n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

2.2 动图演示

选择排序

2.3 代码实现

public static void selectionSort(int[] arr){
        if(arr==null || arr.length<2)
            return;
        for(int i=0;i<arr.length-1;i++){
            // 保存最小数的索引
            int minIndex=i;
            for(int j=i+1;j<arr.length;j++){
                minIndex=arr[j]<arr[minIndex]?j:minIndex;
            }
            swap(arr,minIndex,i);
        }
    }
    public static void swap(int[] arr,int x,int y){
        int temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }

2.4算法分析

最佳情况： $T(n) = O(n^2)$ 最差情况： $T(n) = O(n^2)$ 平均情况： $T(n) = O(n^2)$

选择排序的简单和直观名副其实，这也造就了它”出了名的慢性子”，无论是哪种情况，哪怕原数组已排序完成，它也将花费将近 $\frac{n^2}{2}$ 次遍历来确认一遍。即便是这样，它的排序结果也还是不稳定的。唯一值得高兴的是，它并不耗费额外的内存空间。

3、插入排序

插入排序的设计初衷是往有序的数组中快速插入一个新的元素。它的算法思想是：把要排序的数组分为了两个部分, 一部分是数组的全部元素(除去待插入的元素), 另一部分是待插入的元素; 先将第一部分排序完成, 然后再插入这个元素. 其中第一部分的排序也是通过再次拆分为两部分来进行的.

插入排序由于操作不尽相同, 可分为直接插入排序 , 折半插入排序(又称二分插入排序), 链表插入排序 , 希尔排序。这里介绍的是直接插入排序。直接插入排序的基本思想是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

3.2 动图演示

插入排序

3.3 代码实现

public static void insertionSort(int[] arr){
        if(arr==null || arr.length<2)
            return;
        for(int i=1;i<arr.length;i++){
            for(int j=i-1;j>=0;j--){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }
    public static void swap(int[] arr,int x,int y){
        int temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
        
    }

3.4 算法分析

最好情况下，排序前对象已经按照要求的有序。比较次数(KCN)： $n−1$ ；移动次数(RMN)为0。则对应的时间复杂度为 $O(n)$ 。
最坏情况下，排序前对象为要求的顺序的反序。第i趟时第i个对象必须与前面i个对象都做排序码比较，并且每做1次比较就要做1次数据移动（从上面给出的代码中看出）。比较次数(KCN)： $\sum_{i=1}^{n-1} i=\frac{n(n-1)}{2}\approx\frac{n^2}{2}$ ; 移动次数(RMN)为： $\sum_{i=1}^{n-1} i=\frac{n(n-1)}{2}\approx\frac{n^2}{2}$ 。则对应的时间复杂度为 $O(n2)$ 。
如果排序记录是随机的，那么根据概率相同的原则，在平均情况下的排序码比较次数和对象移动次数约为 $\frac{n^2}{2}$ ，因此，直接插入排序的平均时间复杂度为 $O(n2)$ 。

4、归并排序

归并排序是建立在归并操作上的一种有效的排序算法，1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

归并排序算法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
在这里插入图片描述

4.1 算法描述

归并排序可通过两种方式实现：

自上而下的递归
自下而上的迭代

递归法（假设序列共有n个元素）：

将序列每相邻两个数字进行归并操作，形成 floor(n/2)个序列，排序后每个序列包含两个元素；
将上述序列再次归并，形成 floor(n/4)个序列，每个序列包含四个元素；
重复步骤②，直到所有元素排序完毕。

迭代法

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤③直到某一指针到达序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

4.2 动图演示

这里的是递归法的动图演示
在这里插入图片描述

4.3 代码实现

归并排序其实要做两件事：

分解：将序列每次折半拆分
合并：将划分后的序列段两两排序合并

因此，归并排序实际上就是两个操作，拆分+合并

如何合并？
arr[L…mid]为第一段，L[mid+1…R]为第二段，并且两端已经有序，现在我们要将两端合成达到L[L…R]并且也有序。

首先依次从第一段与第二段中取出元素比较，将较小的元素赋值给help[]
重复执行上一步，当某一段赋值结束，则将另一段剩下的元素赋值给help[]
此时将help[]中的元素复制给arr[]，则得到的arr[L…R]有序

如何分解？
在这里，我们采用递归的方法，首先将待排序列分成A,B两组；然后重复对A、B序列分组；直到分组后组内只有一个元素，此时我们认为组内所有元素有序，则分组结束。

public static void mergeSort(int[] arr){
    if(arr==null || arr.length<2)
        return;
    sortProcess(arr,0,arr.length-1);
}
//先左边的排好序，再右边的排好序，然后合并使整体有序
public static void sortProcess(int[] arr,int L,int R){
    if(L == R)
        return;
    int mid= L+((R-L)>>1); //L和R的中点位置(L+R)/2
    sortProcess(arr,L,mid);
    sortProcess(arr,mid+1,R);
    merge(arr,L,mid,R);
}
//合并排好序的左右两部分
public static void merge(int[] arr,int L,int mid,int R){
    int[] help=new int[R-L+1];
    int i=0;
    int p1=L;
    int p2=mid+1;
    while (p1<=mid && p2<=R){
        help[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
    }
    while (p1<=mid){
        help[i++]=arr[p1++];
    }
    while (p2<=R){
        help[i++]=arr[p2++];
    }
    for(i=0;i<help.length;i++){
        arr[L+i]=help[i];
    }
}

4.4 算法分析

最佳情况： $T(n) = O(n)$ 最差情况： $T(n) = O(nlogn)$ 平均情况： $T(n) = O(nlogn)$

从效率上看，归并排序可算是排序算法中的”佼佼者”. 假设数组长度为n，那么拆分数组共需 $logn$ , 又每步都是一个普通的合并子数组的过程，时间复杂度为 $O(n)$ ，故其综合时间复杂度为 $O(nlogn)$ 。另一方面，归并排序多次递归过程中拆分的子数组需要保存在内存空间，其空间复杂度为 $O(n)$ 。

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。

5、快速排序

快速排序（Quicksort）是对冒泡排序的一种改进，借用了分治的思想，由C. A. R. Hoare在1962年提出。
快速排序的基本思想：挖坑填数+分治法。
首先选一个轴值(pivot，也有叫基准的)，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
在这里插入图片描述

5.1 算法描述

快速排序使用分治策略来把一个序列（list）分为两个子序列（sub-lists）。步骤为：

从数列中挑出一个元素，称为”基准”（pivot）。
重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

5.2 动图演示

在这里插入图片描述

5.3 代码实现

代码实现的是使用荷兰国旗问题改进的随机快速排序

public static void quickSort(int[] arr){
    if(arr==null || arr.length<2)
        return;
    quickSort(arr,0,arr.length-1);
}

public static void quickSort(int[] arr,int l,int r){
    if(l<r){
        swap(arr,l+(int)(Math.random()*(r-l+1)),r);//随机快排
        int[] p=partition(arr,l,r);//使用荷兰国旗问题的方法改进，一次可以确定多个相同的数
        quickSort(arr,l,p[0]-1);
        quickSort(arr,p[1]+1,r);
    }
}

public static int[] partition(int[] arr,int l,int r){
    int less=l-1;
    int more=r;
    while (l<more){
        if(arr[l]<arr[r]){
            swap(arr,++less,l++);
        }else if(arr[l]>arr[r]){
            swap(arr,--more,l);
        }else
            l++;
    }
    swap(arr,more,r);
    return new int[]{less+1,more}; // =num 的左右边界
}

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

5.4 算法分析

最佳情况： $T(n) = O(n\log_2n)$ 最差情况： $T(n) = O(n^2)$ 平均情况： $T(n) = O(n\log_2n)$ 　
快速排序是通常被认为在同数量级 $O(n\log_2n)$ 的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。或随机选择一个待排数组中的数做为基准。快速排序是一个不稳定的排序方法。

快速排序排序效率非常高。虽然它运行最糟糕时将达到 $O(n²)$ 的时间复杂度, 但通常平均来看, 它的时间复杂为 $O(n\log_2n)$ , 比同样为 $O(n\log_2n)$ 时间复杂度的归并排序还要快. 快速排序似乎更偏爱乱序的数列, 越是乱序的数列, 它相比其他排序而言, 相对效率更高.

使用荷兰国旗问题改进的快速排序算法的额外空间复杂度为 $O(\log_2n)$
经典的快速排序算法的额外空间复杂度为 $O(1)$

Tips: 同选择排序相似, 快速排序每次交换的元素都有可能不是相邻的, 因此它有可能打破原来值为相同的元素之间的顺序. 因此, 快速排序并不稳定.

6、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

6.1 算法描述

将初始待排序关键字序列 $(R_1,R_2….R_n)$ 构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区 $(R_1,R_2,……R_{n-1})$ 和新的有序区 $(R_n)$ ,且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区 $(R_1,R_2,……R_{n-1})$ 调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区 $(R_1,R_2,……R_{n-2})$ 和新的有序区 $(R_{n-1},R_n)$ 。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

6.2 动图演示

在这里插入图片描述

6.3 代码实现

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆函数，二是反复调用建堆函数以选择出剩余未排元素中最大的数来实现排序的函数。

总结起来就是定义了以下几种操作：

最大堆调整（heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
创建最大堆（heapInsert）：将堆所有数据重新排序
堆排序（heapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算
对于堆节点的访问：

父节点i的左子节点在位置：(2i+1);
父节点i的右子节点在位置：(2i+2);
子节点i的父节点在位置：floor((i-1)/2);

public static void heapSort(int[] arr){
    if(arr==null || arr.length<2)
        return;
    //创建一个大根堆
    for(int i=0;i<arr.length;i++){
        heapInsert(arr,i);
    }
    //大根堆的第一个数和最后一个数交换
    int size=arr.length;
    swap(arr,0,--size); //交换之后大根堆对应的数组长度减一
    //调整交换后的数组(交换后的数组大小减一，此时排好一个数)
    while (size>0){
        heapify(arr,0,size);
        swap(arr,0,--size);
    }
}

//插入一个数，使当前数组为一个大根堆
public static void heapInsert(int[] arr,int index){
    while (arr[index]>arr[(index-1)/2]){//插入的数大于他的父节点，一直向上调整直到父节点大于index
        swap(arr,index,(index-1)/2);
        index=(index-1)/2;
    }
}

//当大根堆中有一个数变小时，调整大根堆
public static void heapify(int[] arr,int index,int size){
    int left=2*index+1;//左孩子
    while (left<size){
        int largest; //记录左右孩子和index中较大的数的下标
        if(left+1<size && arr[left+1]>arr[left]){ //右孩子存在且右孩子大于左孩子,较大的数的下标为右孩子的下标
            largest=left+1;
        }else  //否则，较大的数的下标为左孩子的下标
            largest=left;
        largest = arr[largest] > arr[index] ? largest : index; //比较孩子节点中较大的值是否比当前值大，记录较大的值
        if (largest == index) { //如果当前值就是当前值和左右孩子节点的值中最大的，则不再需要调整
            break;
        }
        swap(arr, largest, index); //否则当前值和左右孩子中较大的交换
        index = largest;//继续上面的过程
        left = index * 2 + 1;
    }
}

6.4 算法分析

①. 建立堆的过程, 从length/2 一直处理到0, 时间复杂度为 $O(n)$ ;
②. 调整堆的过程是沿着堆的父子节点进行调整, 执行次数为堆的深度, 时间复杂度为 $O(log_2n)$ ;
③. 堆排序的过程由n次第②步完成, 时间复杂度为 $O(nlog_2n)$ .
最佳情况： $T(n) = O(nlog_2n)$ 最差情况： $T(n) = O(nlog_2n)$ 平均情况： $T(n) = O(nlog_2n)$
Tips: 由于堆排序中初始化堆的过程比较次数较多, 因此它不太适用于小序列. 同时由于多次任意下标相互交换位置, 相同元素之间原本相对的顺序被破坏了, 因此, 它是不稳定的排序.

7、计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

7.1 算法描述

找出待排序的数组中最大和最小的元素；
统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

7.2 动图演示

在这里插入图片描述

7.3 代码实现

7.4 算法分析

8、桶排序

8.1 算法描述

8.2 动图演示

8.3 代码实现

8.4 算法分析

9、基数排序

9.1 算法描述

9.2 动图演示

9.3 代码实现

9.4 算法分析

10、工程中的综合排序算法

工程中的综合排序算法使用多种算法。
数组长度很长时，首先判断是否是基础类型：

基础类型：快速排序。基础类型值一样的都一样，因此不需要稳定性
自定义类型：归并排序

数组长度很短时（小于60），直接用插入排序，因为插入排序常数项很低，在小样本情况下n平方的劣势显示不出来。
在递归的情况下，当子问题规模小于一定值（例如60）时开始使用插入排序。

11、有关排序问题的补充:

1.归并排序的额外空间复杂度可以变成O(1)，但是非常难，不需要掌握，可以搜“归并排序内部缓存法”
2.快速排序可以做到稳定性问题，但是非常难，不需要掌握，可以搜“01 stable sort”
(荷兰国旗问题不能实现稳定性)
3.有一道题目，是奇数放在数组左边，偶数放在数组右边，还要求原始的相对次序不变，额外空间复杂度O(1),时间复杂度O(n)。碰到这个问题，可以怼面试官，面试官非良人。就是01 stable sort问题，很难。快速排序做不到稳定性。

花千树hss

发布了13 篇原创文章 · 获赞 0 · 访问量 144

私信关注

排序算法总结和java实现

排序算法总结和java实现

0、排序算法说明

0.1 排序的定义

0.2 术语说明

0.3 算法总结

0.4 算法分类

0.5 比较和非比较的区别

1、冒泡排序

1.1 算法描述

1.2 动图演示

1.3 代码实现

1.4 算法分析

2、选择排序

2.1 算法描述

2.2 动图演示

2.3 代码实现

2.4算法分析

3、插入排序

3.1 算法描述

3.2 动图演示

3.3 代码实现

3.4 算法分析

4、归并排序

4.1 算法描述

4.2 动图演示

4.3 代码实现

4.4 算法分析

5、快速排序

5.1 算法描述

5.2 动图演示

5.3 代码实现

5.4 算法分析

6、堆排序

6.1 算法描述

6.2 动图演示

6.3 代码实现

6.4 算法分析

7、计数排序

7.1 算法描述

7.2 动图演示

7.3 代码实现

7.4 算法分析

8、桶排序

8.1 算法描述

8.2 动图演示

8.3 代码实现

8.4 算法分析

9、基数排序

9.1 算法描述

9.2 动图演示

9.3 代码实现

9.4 算法分析

10、工程中的综合排序算法

11、有关排序问题的补充:

猜你喜欢