文章目录
排序的概念
所谓排序，就是使一串数据，按照某种比较规则，递增或递减地排列的操作。
稳定性：假定在待排序的数据中，存在多个相同数据，若经过排序，这些数据的相对次序保持不变，则称这种排序算法是稳定的；否则称为不稳定的。
- 一个本身就不稳定的排序，是不可能变成一个稳定的排序的
- 但是一个本身就稳定的排序，是可以实现为不稳定的排序的
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，外存中的数据读入内存→在内存中排序→数据写入外存。
常见的排序算法
插入排序
直接插入排序的基本思想是：把数据逐个插入到一个已经有序的序列中，直到所有的记录插入完得到一个新的有序序列 。
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int tmp = array[i];
int j = i-1;
for (; j >= 0 ; j--) {
//加不加等号能决定这个排序的稳定性,也就是array[j] >= tmp是不稳定的
if(array[j] > tmp) {
array[j+1] = array[j];
}else {
break;
}
}
array[j+1] = tmp;
}
}
直接插入排序的特性总结：
- 数据越趋于有序，直接插入排序算法的时间效率越高
- 时间复杂度：
- 最好情况：数据有序的情况下：O(N)
- 最坏情况：数据逆序的情况下:O( N 2 N^2 N2)
- 空间复杂度：O(1)
- 稳定性：稳定
希尔排序( 缩小增量排序 )
希尔排序的基本思想是：先选定一个整数gap，把待排序的元素分成gap组，所有距离为gap的元素分在同一组，并对每一组的元素进行插入排序。然后，取新的gap，重复上述分组和排序的工作。当gap ==1时，所有元素排好序。
- 跳跃式分组尽可能把大的元素放到后边,小的元素放到前边
- 除了gap == 1以外的排序都是预排序,每次预排序后都接近有序,最后gap == 1的时候,整体插入排序效率就高了
时间复杂度我们暂时就按照O( N 1.25 N^{1.25} N1.25)到O(1.6 N 1.25 N^{1.25} N1.25)来算。
’
以gap = gap/2为例
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
gap = gap / 2;
shell(array,gap);
}
}
private static void shell(int[] array,int gap) {
for (int i = gap; i < array.length; i++) {
int tmp = array[i];
int j = i-gap;
for (; j >= 0 ; j-=gap) {
if(array[j] > tmp) {
array[j+gap] = array[j];
}else {
break;
}
}
array[j+gap] = tmp;
}
}
希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数据更接近于有序。当gap == 1时，数据已经接近有序了，这样插入排序效率会高,可以达到优化的效果。
- 希尔排序的时间复杂度不好计算，因为gap的取值方法很多
- 稳定性：不稳定
选择排序
每一次从待排序的数据中选出最小（或最大）的一个元素，存放在相应位置，直到全部数据排完 。
public static void selectSort(int[] array) {
for (int i = 0; i < array.length-1; i++) {
int minIndex = i;
for (int j = i+1; j < array.length; j++) {
if(array[j] < array[minIndex]) {
minIndex = j;
}
}
swap(array,i,minIndex);
}
}
private static void swap(int[] array,int i,int j) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
还有一种:
public static void selectSort2(int[] array) {
int left = 0;
int right = array.length-1;
while (left < right) {
int minIndex = left;
int maxIndex = left;
for (int i = left+1; i <= right ; i++) {
if(array[i] < array[minIndex]) {
minIndex = i;
}
if(array[i] > array[maxIndex]) {
maxIndex = i;
}
}
swap(array,minIndex,left);
//第一次交换 最大值可能是left,然后被换到了minIndex的位置
if(maxIndex == left) {
maxIndex = minIndex;
}
swap(array,maxIndex,right);
left++;
right--;
}
}
private static void swap(int[] array,int i,int j) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
【直接选择排序的特性总结】
- 直接选择排序效率不是很好。实际中很少使用
- 时间复杂度：O( N 2 N^2 N2)
- 空间复杂度：O(1)
- 稳定性：不稳定
堆排序
堆排序即利用堆的思想来进行排序，总共分为两个步骤：
- 建堆
升序：建大堆
降序：建小堆 - 利用堆删除思想来进行排序
用到向下调整
public static void heapSort(int[] array){
//创建大根堆
createHeap(array);
int end = array.length-1;
while (end > 0) {
swap(array,0,end);
siftDown(array,0,end--);
}
}
private static void createHeap(int[] array) {
for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
siftDown(array,parent,array.length);
}
}
private static void swap(int[] array,int i,int j) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
private static void siftDown(int[] array,int parent,int len) {
int child = (2*parent)+1;
while (child < len) {
if(child + 1 < len && array[child] < array[child+1]) {
child = child+1;
}
//child一定是 左右孩子最大值的下标
if(array[child] > array[parent]) {
swap(array,child,parent);
parent = child;
child = 2*parent+1;
}else {
break;
}
}
}
常见习题：
1.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为()
A: (11 5 7 2 3 17) B: (11 5 7 2 17 3) C: (17 11 7 2 3 5)
D: (17 11 7 5 3 2) E: (17 7 11 3 5 2) F: (17 7 11 3 2 5)
答案：C
【堆排序的特性总结】
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
冒泡排序
public static void bubbleSort(int[] array) {
//i代表趟数
for (int i = 0; i < array.length-1; i++) {
boolean flg = false;
for(int j = 0;j < array.length-1-i;j++) {
if(array[j] > array[j+1]) {
swap(array,j,j+1);
flg = true;
}
}
//没有交换证明有序了
if(flg == false) {
return;
}
}
}
【冒泡排序的特性总结】
- 时间复杂度：O ( N 2 ) (N^2) (N2)
- 空间复杂度：O(1)
- 稳定性：稳定
快速排序
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，以该元素为基准将待排序序列分割成两子列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
主框架如下:
public static void quickSort(int[] array) {
quick(array,0,array.length-1);
}
void quick(int[] array, int start, int end) {
if(start >= end) {
return;
}
// 按照基准值对array数组的 [left, right)区间中的元素进行划分
int pivot = partition(array, start, end);
quick(array, start, pivot-1);
quick(array, pivot+1, end);
}
int partition(int[] array, int left, int right) {
}
只需分析如何按照基准值来对区间中数据进行划分即可。将区间按照基准值划分为左右两部分的常见方式有：
Hoare法
-
时间复杂度：
- 最好情况下：O(N*logN)
- 最坏情况下(有序 / 逆序)： O ( N 2 ) O(N^2) O(N2)
-
空间复杂度：
- 最好情况下：O(logN)
- 最坏情况下(有序 / 逆序)：O(N)
-
稳定性: 不稳定的排序
public static void quickSort(int[] array) {
quick(array,0,array.length-1);
}
void quick(int[] array, int start, int end) {
if(start >= end) {
return;
}
int pivot = partition(array, start, end);
quick(array, start, pivot-1);
quick(array, pivot+1, end);
}
private static void swap(int[] array,int i,int j) {
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
private static int partition (int[] array,int left,int right) {
int tmp = array[left];//基准
int i = left;
while (left < right) {
while (left < right && array[right] >= tmp) {
right--;
}
while (left < right && array[left] <= tmp) {
left++;
}
swap(array,left,right);
}
swap(array,i,left);
return left;
}
挖坑法
private static int partition(int[] array,int left,int right) {
int tmp = array[left];
while (left < right) {
while (left < right && array[right] >= tmp) {
right--;
}
if(left == right) {
break;
}
array[left] = array[right];
while (left < right && array[left] <= tmp) {
left++;
}
if(left == right) {
break;
}
array[right] = array[left];
}
array[left] = tmp;
return left;
}
前后指针(只需了解)
写法一:
private static int partition(int[] array, int left, int right) {
int prev = left ;
int cur = left+1;
while (cur <= right) {
if(array[cur] < array[left] && array[++prev] != array[cur]) {
swap(array,cur,prev);
}
cur++;
}
swap(array,prev,left);
return prev;
}
写法二:
private static int partition(int[] array, int left, int right) {
int end = left + 1;
int pivot = array[left];
for (int i = left + 1; i <= right; i++) {
if (array[i] < pivot) {
swap(array, i, end);
end++;
}
}
swap(array, end - 1, left);
return end - 1;
}
快速排序优化
- 三数取中法选key
- 递归到小的子区间时，因为已经趋于有序,可以考虑使用插入排序
private static void quick(int[] array,int start,int end) {
if(start >= end) {
return;
}
//小的子区间进行插入排序
if(end-start+1 <= 15) {
insertSort(array, start, end);
return;
}
//1. 三数取中 index是中间大的数字 的 下标
int index = middleNum(array,start,end);
swap(array,index,start);
int pivot = partition(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
public static void insertSort(int[] array,int start,int end) {
for (int i = start+1; i <= end; i++) {
int tmp = array[i];
int j = i-1;
for (; j >= start ; j--) {
if(array[j] > tmp) {
array[j+1] = array[j];
}else {
break;
}
}
array[j+1] = tmp;
}
}
private static int middleNum(int[] array,int left,int right) {
int mid = left+((right-left) >> 1);
//相当于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 {
if(array[mid] < array[right]) {
return right;
}else if(array[mid] > array[left]) {
return left;
}else {
return mid;
}
}
}
快速排序非递归
public static void quickSortNor(int[] array) {
Stack<Integer> stack = new Stack<>();
int left = 0;
int right = array.length-1;
int pivot = partition(array,left,right);
if(pivot-1 > left) {
stack.push(left);
stack.push(pivot-1);
}
if(pivot + 1 < right) {
stack.push(pivot+1);
stack.push(right);
}
while (!stack.isEmpty()) {
right = stack.pop();
left = stack.pop();
pivot = partition(array,left,right);
if(pivot-1 > left) {
stack.push(left);
stack.push(pivot-1);
}
if(pivot + 1 < right) {
stack.push(pivot+1);
stack.push(right);
}
}
}
快速排序总结
- 快速排序整体的综合性能和使用场景都是比较好的，所以才叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将有序的子序列合并，得到完全有序的序列.
public static void mergeSort(int[] array) {
mergeFunc(array,0,array.length-1);
}
private static void mergeFunc(int[] array,int left,int right) {
if(left >= right) {
return;
}
int mid = left + ((right-left) >> 1);
mergeFunc(array,left,mid);
mergeFunc(array,mid+1,right);
//左边分解完，右边分解完，开始合并
merge(array,left,mid,right);
}
private static void merge(int[] array,int left,int mid,int right) {
int s1 = left;
int e1 = mid;
int s2 = mid+1;
int e2 = right;
int[] tmpArr = new int[right-left+1];
int k = 0;
//1.保证两个表 都有数据
while (s1 <= e1 && s2 <= e2) {
if(array[s1] <= array[s2]) {
tmpArr[k++] = array[s1++];
}else {
tmpArr[k++] = array[s2++];
}
}
//2. 看哪个数组 还有数据 拷贝回去
while (s1 <= e1) {
tmpArr[k++] = array[s1++];
}
while (s2 <= e2) {
tmpArr[k++] = array[s2++];
}
//3.拷贝到源数组
for (int i = 0; i < k; i++) {
array[i+left] = tmpArr[i];
}
}
非递归实现归并排序：
public static void mergeSortNor(int[] array) {
int gap = 1;
//gap是待排序的个子组的元素个数
while (gap < array.length) {
//对子组两两进行排序
for (int i = 0; i < array.length; i = i+2*gap) {
int left = i;
int mid = left + gap-1;
if(mid >= array.length) {
mid = array.length-1;
}
int right = mid+gap;
if(right >= array.length) {
right = array.length-1;
}
merge(array,left,mid,right);
}
gap *= 2;
}
}
private static void merge(int[] array,int left,int mid,int right) {
int s1 = left;
int e1 = mid;
int s2 = mid+1;
int e2 = right;
int[] tmpArr = new int[right-left+1];
int k = 0;
//1.保证两个表 都有数据
while (s1 <= e1 && s2 <= e2) {
if(array[s1] <= array[s2]) {
tmpArr[k++] = array[s1++];
}else {
tmpArr[k++] = array[s2++];
}
}
//2. 看哪个数组 还有数据 拷贝回去
while (s1 <= e1) {
tmpArr[k++] = array[s1++];
}
while (s2 <= e2) {
tmpArr[k++] = array[s2++];
}
//3.拷贝到源数组
for (int i = 0; i < k; i++) {
array[i+left] = tmpArr[i];
}
}
归并排序总结
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
海量数据的排序问题
外部排序：排序过程对在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
- 先把文件切分成 200 份，每个 512 M
- 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
- 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了
排序算法复杂度及稳定性分析
数据敏感的意思是数据越有序,排序速度越快(冒泡,插入,希尔),数据越有序,排序速度越慢(快排).对于其余排序,数据是否有序对其效率影响不大
| 排序方法 | 最好时间 | 平均时间 | 最坏时间 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | 优化后O(n) | O( n 2 n^2 n2) | O( n 2 n^2 n2) | O(1) | 稳定 |
| 插入排序 | O(n) | O( n 2 n^2 n2) | O( n 2 n^2 n2) | O(1) | 稳定 |
| 选择排序 | O( n 2 n^2 n2) | O( n 2 n^2 n2) | O( n 2 n^2 n2) | O(1) | 不稳定 |
| 希尔排序 | O(n) | O( n 1.3 n^{1.3} n1.3) | O( n 2 n^2 n2) | O(1) | 不稳定 |
| 堆排序 | O(n*logn) | O(n*logn) | O(n*logn) | O(1) | 不稳定 |
| 快速排序 | O(n*logn) | O(n*logn) | O( n 2 n^2 n2) | O(logn) ~ O(n) | 不稳定 |
| 归并排序 | O(n*logn) | O(n*logn) | O(n*logn) | O(n) | 稳定 |
其他排序（只需了解）
计数排序
思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：
- 统计相同元素出现次数
- 根据统计的结果将序列回收到原来的序列中
public static void countSort(int[] array) {
//1.求最值
int min = array[0];
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(min > array[i]) {
min = array[i];
}
if(max < array[i]) {
max = array[i];
}
}
//2、定义计数数组 进行初始化
int[] count = new int[max-min+1];
for (int i = 0; i < array.length; i++) {
int index = array[i]-min;
count[index]++;
}
//3、遍历计数数组
int k = 0;//表示array数组的下标
for (int i = 0; i < count.length; i++) {
while (count[i] != 0) {
array[k++] = i + min;
count[i]--;
}
}
}
}
【计数排序的特性总结】
- 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
- 时间复杂度：O(范围+n)
- 空间复杂度：O(范围)
- 稳定性：稳定
基数排序
最大值的位数,就是进出的次数
桶排序
选择题
- 快速排序算法是基于()的一个排序算法。
A：分治法 B：贪心法 C：递归法 D：动态规划法
选A
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较()次？（采用从后往前比较）
A: 3 B: 4 C: 5 D: 6
5次,选C
3.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序
没有简单排序,选D
4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序
选B
5.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 “冒泡排序”，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
选D,堆排序空间复杂度的为O(1)
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
首先试挖坑法,再是Hoare法,最后是前后指针法
选A
3686
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
