文章目录
- 一、排序的概念
- 二、常见的排序算法
- 三、常见排序算法的实现
- 1.插入排序
- 1、基本思想
- 2、直接插入排序
- 3、希尔排序（缩小增量排序）
- 2.选择排序
- 1、基本思想
- 2、直接选择排序
- 2、堆排序
- 3.交换排序
- 1、冒泡排序
- 2、快速排序
- 3、快速排序优化
- 4、快速排序非递归
- 4.归并排序
- 1、基本思想
- 2、海量数据的排序问题
- 四、排序算法复杂度及稳定性分析
- 五、练习
一、排序的概念
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
二、常见的排序算法
三、常见排序算法的实现
1.插入排序
1、基本思想
直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
2、直接插入排序
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移
时间复杂度:
最坏情况下：O(n^2)
最好情况下：O(n) 当数据越有序，排序越快
适用于：待排序序列 已经基本上趋于有序了
空间复杂度：
O(1)
稳定性：
稳定
逻辑：
假设这组数据的第一个元素是有序的，从第二个元素开始，依次和前面的元素进行比较找到合适的位置就进行插入。
代码实现：
public static void insertSort(int[] array)
{
if(array==null||array.length<=1)
{
return;
}
for(int end = 1;end<array.length;end++)
{
int temp = array[end];
int cur = end-1;
while(cur>=0)
{
if(array[cur]>temp)
{
array[cur+1] =array[cur];
cur--;
}
else
{
break;
}
}
array[cur+1] = temp;
}
}
测试代码：
public static void main(String[] args) {
int [] array ={27,15,9,18,28};
insertSort(array);
System.out.println(Arrays.toString(array));
}
3、希尔排序（缩小增量排序）
希尔排序法又称缩小增量法。希尔排序法的基本思想是：
先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
gap = 5 和 gap = 3是预排序，每组插入排序的优点是越有序越快，当gap = 5时，每组数据少，当gap = 3越来越有序了，直到gap =1时，虽然数据量大了，但也有序了。
希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
- 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，暂时按照O(n1.25)到O(1.6*n1.25)
- 稳定性：不稳定
代码实现：
public static void shellSort(int [] array)
{
int gap = array.length;
while(gap>1)
{
gap /=2;
shell(array,gap);
}
}
public static void shell(int [] array,int gap)
{
for(int end = gap;end<array.length;end++)
{
int temp = array[end];
int cur = end-gap;
while(cur>=0)
{
if(array[cur]>temp)
{
array[cur+gap] = array[cur];
cur-=gap;
}
else
{
break;
}
}
array[cur+gap] = temp;
}
}
测试代码：
public static void main(String[] args) {
int [] array ={27,15,9,18,28,-100};
// insertSort(array);
shellSort(array);
System.out.println(Arrays.toString(array));
}
2.选择排序
1、基本思想
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
2、直接选择排序
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
直接选择排序的特性总结：
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
代码实现：
public static void selectSort(int []array)
{
int len = array.length;
for(int end = len-1;end>0;end--)
{
int maxIndex = 0;
for(int cur = 0;cur<=end;cur++)
{
if(array[maxIndex]<array[cur])
{
maxIndex = cur;
}
}
int temp = array[end];
array[end] = array[maxIndex];
array[maxIndex] =temp;
}
}
优化：
可以在一次遍历时，记录最小值的引索和最大值的引索，这是双向选择。
代码实现：
public static void selectSort2(int []array)
{
int len = array.length;
for(int begin = 0,end = len-1;begin<end;begin++,end--)
{
int maxIndex = begin;
int minIndex = begin;
int cur = begin;
while(cur<=end)
{
if(array[maxIndex]<array[cur])
{
maxIndex = cur;
}
if(array[minIndex]>array[cur])
{
minIndex = cur;
}
cur++;
}
if(maxIndex == begin)
{
maxIndex = minIndex;
}
swap(array,begin,minIndex);
swap(array,end,maxIndex);
}
}
public static void swap(int [] array,int i,int j)
{
int temp = array[i];
array[i] = array[j];
array[j] =temp;
}
注意：
最后交换位置的时候，最小位置和最小引索交换，可能会导致最大值被换到其他位置，所以要在交换前检查 maxIndex和begin是否一样。
2、堆排序
堆排序（Heapsort）是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
堆排序的特性总结：
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
代码实现：
public static void createHeap(int [] array)
{
int len = array.length;
for(int cur =(len-1-1)/2;cur>=0;cur--)
{
siftDown(array,cur,len);
}
}
public static void heapSort(int [] array)
{
createHeap(array);
for(int end = array.length-1;end>0;end--)
{
swap(array,0,end);
siftDown(array,0,end);
}
}
public static void siftDown(int [] array,int parent,int useSize)
{
int child = parent*2+1;
while(child<useSize)
{
if(child+1<useSize&&array[child+1]>array[child])
{
child = child+1;
}
if(array[parent]<array[child])
{
swap(array,parent,child);
parent = child;
child = parent*2+1;
}
else
{
break;
}
}
}
测试代码：
public static void main(String[] args) {
int [] array ={ 100,27,15,9,18,28,-100,20};
// insertSort(array);
// shellSort(array);
// selectSort(array);
// selectSort2(array);
heapSort(array);
System.out.println(Arrays.toString(array));
}
3.交换排序
基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动
1、冒泡排序
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。
代码实现：
public static void bubbleSort(int[] array)
{
for(int i = 0;i<array.length-1;i++)
{
boolean flag = true;
for(int j = 1;j<array.length-i;j++)
{
if(array[j]<array[j-1])
{
swap(array,j,j-1);
flag = false;
}
}
if(flag)
{
break;
}
}
}
测试代码：
public static void main(String[] args) {
int [] array ={ 100,27,15,9,18,28,-100,20};
int [] array2 = {1,2,3,4,5};
// insertSort(array);
// shellSort(array);
// selectSort(array);
// selectSort2(array);
// heapSort(array);
bubbleSort(array);
bubbleSort(array2);
System.out.println(Arrays.toString(array));
System.out.println(Arrays.toString(array2));
}
2、快速排序
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
快速排序总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
代码实现Hoare版本：
public static void quickSort(int [] array)
{
quick(array,0,array.length-1);
}
public static void quick(int[]array,int start,int end )
{
if(start>=end)
{
return;
}
int pivot = partitionHoare(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
private static int partitionHoare(int[] array, int left, int right) {
int temp = array[left];
int i = left;
while(left<right)
{
//找小于temp
while(left<right && array[right]>=temp)
{
right--;
}
//找大于temp
while(left<right && array[left]<=temp)
{
left++;
}
swap(array,left,right);
}
swap(array,i,left);
return left;
}
代码实现挖坑法：
public static void quickSort(int [] array)
{
quick(array,0,array.length-1);
}
public static void quick(int[]array,int start,int end )
{
if(start>=end)
{
return;
}
int pivot = partitionHole(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
private static int partitionHole(int[] array, int left, int right) {
int temp = array[left];
while(left<right)
{
if(left<right&&array[right]>=temp)
{
right--;
}
array[left] = array[right];//现在坑变成right
if(left<right&&array[left]<=temp)
{
left++;
}
array[right] =array[left];
}
array[left] =temp;
return left;
}
思考：
-
为什么array[right]>=temp 和array[left]<=temp要取=？
会造成死循环 -
为什么先从右边而不是先从左边？
对于Hoare法，如果先走左边有可能出现相遇的是大的数据，最后把大的数据放到了最前面。
代码实现前后指针：
public static void quickSort(int [] array)
{
quick(array,0,array.length-1);
}
public static void quick(int[]array,int start,int end )
{
if(start>=end)
{
return;
}
int pivot = partitionD(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
private static int partitionD(int[] array, int left, int right) {
int temp = array[left];
int prev = left;
int cur = left+1;
//[left,prev]是<=temp
//[prev+1,cur)是>temp
//[cur,right]是待排
while(cur<=right)
{
if(array[cur]>temp)
{
cur++;
}
else
{
swap(array,++prev,cur++);
}
}
swap(array,left,prev);
return prev;
}
3、快速排序优化
出发点：减少递归次数
- 三数取中法选key
- 递归到小的子区间时，可以考虑使用插入排序
优化后的代码：
public static void insertSort(int[] array,int left,int right)
{
if(array==null||array.length<=1)
{
return;
}
for(int end = left+1;end<=right;end++)
{
int temp = array[end];
int cur = end-1;
while(cur>=0)
{
if(array[cur]>temp)
{
array[cur+1] =array[cur];
cur--;
}
else
{
break;
}
}
array[cur+1] = temp;
}
}
public static void quickSort(int [] array)
{
quick(array,0,array.length-1);
}
public static void quick(int[]array,int start,int end )
{
if(end-start+1<3)
{
insertSort(array,start,end);
return;
}
int mid = middleNum(array,start,end);
swap(array,mid,start);
int pivot = partitionD(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
public static int middleNum(int [] array,int left,int right)
{
int mid = (left+right)/2;
if(array[left]<array[right])
{
if(array[mid]<array[left])
{
return left;
}
else if(array[mid]>array[right])
{
return right;
}
else
{
return mid;
}
}
else
{
//left>right
if(array[mid]>array[left])
{
return left;
}
else if(array[mid]<array[right])
{
return right;
}
else
{
return mid;
}
}
}
private static int partitionD(int[] array, int left, int right) {
int temp = array[left];
int prev = left;
int cur = left+1;
//[left,prev]是<=temp
//[prev+1,cur)是>temp
//[cur,right]是待排
while(cur<=right)
{
if(array[cur]>temp)
{
cur++;
}
else
{
swap(array,++prev,cur++);
}
}
swap(array,left,prev);
return prev;
}
4、快速排序非递归
把划分两个区间的左右边界存到栈里，不断拿出区间快排，划分两个区间，存入栈里，直到栈为空时，即表示数组排完。
快速排序总结
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
代码实现：
public static void quickSortNonR(int[] array, int left, int right) {
Stack<Integer> stack = new Stack<>();
stack.push(left);
stack.push(right);
while(!stack.isEmpty())
{
int end = stack.pop();
int begin = stack.pop();
if(begin>=end)
{
continue;
}
int mid = middleNum(array,begin,end);
swap(array,begin,mid);
int key = array[begin];
int prev = begin;
int cur = prev+1;
//[begin,prev] 是<=key
//[prev,cur)是>key
//[cur,end]是待排序列
while(cur<=end)
{
if(array[cur]<key)
{
swap(array,++prev,cur++);
}
else
{
cur++;
}
}
swap(array,begin,prev);
if(prev-1>begin)
{
stack.push(begin);
stack.push(prev-1);
}
if(prev+1<end)
{
stack.push(prev+1);
stack.push(end);
}
}
}
public static void swap(int [] array,int i,int j)
{
int temp = array[i];
array[i] = array[j];
array[j] =temp;
}
public static int middleNum(int [] array,int left,int right)
{
int mid = (left+right)/2;
if(array[left]<array[right])
{
if(array[mid]<array[left])
{
return left;
}
else if(array[mid]>array[right])
{
return right;
}
else
{
return mid;
}
}
else
{
//left>right
if(array[mid]>array[left])
{
return left;
}
else if(array[mid]<array[right])
{
return right;
}
else
{
return mid;
}
}
}
测试代码：
public static void main(String[] args) {
int [] array ={ 100,27,15,9,18,28,-100,20};
quickSortNonR(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
4.归并排序
1、基本思想
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
归并排序总结
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
递归代码实现：
public static void mergeSort(int []array)
{
mergeSortFun(array,0,array.length-1);
}
public static void mergeSortFun(int[] array, int left, int right) {
if(left>=right)
{
return;
}
int mid = (left+right)/2;
mergeSortFun(array,left,mid);
mergeSortFun(array,mid+1,right);
merge(array,left,mid,right);
}
public static void merge(int[] array,int left,int mid ,int right)
{
int capacity = right-left+1;
int [] temp = new int [capacity];
int begin1 = left;
int begin2 = mid+1;
int k = 0;
while(begin1<=mid&&begin2<=right)
{
if(array[begin1]<=array[begin2])
{
temp[k++] = array[begin1++];
}
else
{
temp[k++] =array[begin2++];
}
}
while(begin1<=mid)
{
temp[k++] = array[begin1++];
}
while(begin2<=right)
{
temp[k++] = array[begin2++];
}
for(int i = 0;i<k;i++)
{
array[i+left] = temp[i];
}
}
归并排序非递归代码实现：
public static void mergeSortNor(int [] array)
{
int gap = 1;
while(gap<array.length)
{
for(int i = 0;i<array.length;i+=2*gap)
{
int left = i;
// int mid = left+gap-1;
// int right = mid+gap;
int mid = Math.min(left+gap-1,array.length-1);
int right = Math.min(mid + gap, array.length - 1);
int [] temp = new int [2*gap];
int k = 0;
int begin1 = left;
int begin2 = mid+1;
while(begin1<=mid&&begin2<=right)
{
if(array[begin1]<array[begin2])
{
temp[k++] = array[begin1++];
}
else {
temp[k++] =array[begin2++];
}
}
while (begin1<=mid)
{
temp[k++]=array[begin1++];
}
while (begin2<=right)
{
temp[k++] = array[begin2++];
}
for(int j = 0;j<k;j++)
{
array[left+j] = temp[j];
}
}
gap*=2;
}
}
2、海量数据的排序问题
外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
- 先把文件切分成 200 份，每个 512 M
- 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
- 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了
四、排序算法复杂度及稳定性分析
O(n^2) O(n^2) O(1) 稳定
选择排序 O(n^2) O(n^2) O(n^2) O(1) 不稳定
希尔排序 O(n) O(n^1.3) O(n^2) O(1) 不稳定
堆排序 O(n * log(n)) O(n * log(n)) O(n * log(n)) O(1) 不稳定
快速排序 O(n * log(n)) O(n * log(n)) O(n^2) O(log(n)) ~ O(n) 不稳定
归并排序 O(n * log(n)) O(n * log(n)) O(n * log(n)) O(n) 稳定
| 排序方法 | 最好 | 平均 | 最坏 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
| 插入排序 | O(n) | O(n^2) | O(n^2) | O(1) | 稳定 |
| 选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | 不稳定 |
| 希尔排序 | O(n) | O(n^1.3) | O(n^2) | O(1) | 不稳定 |
| 堆排序 | O(n*logn) | O(n*logn) | O(n*logn) | O(1) | 不稳定 |
| 快速排序 | O(n*logn) | O(n*logn) | O(n^2) | O(long(n))~O(n) | 不稳定 |
| 归并排序 | O(n*logn) | O(n*logn) | O(n*logn) | O(n) | 稳定 |
五、练习
题目：
1. 快速排序算法是基于()的一个排序算法。
A：分治法 B：贪心法 C：递归法 D：动态规划法
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入
位置需比较()次？（采用从后往前比较）
A: 3 B: 4 C: 5 D: 6
3.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序
4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序
5.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 "冒泡排序"，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
6.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A: 34，56，25，65，86，99，72，66 B: 25，34，56，65，99，86，72，66
C: 34，56，25，65，66，99，86，72 D: 34，56，25，65，99，86，72，66
答案：
1.A 2.C 3.D 4.B 5.D 6.A
