本文详细介绍了六种常见的排序算法：冒泡排序、选择排序、插入排序、快速排序、堆排序和归并排序，包括它们的时间复杂度和稳定性特点。此外，还特别讨论了归并排序在解决小和与逆序对问题上的应用。
3. 排序算法
总结：
- 稳定性：值相同的数，排完序后数字的相对位置不变。
- 基础类型没用，一些实际中的非基础类型，对稳定性有要求
六种常用的排序
冒泡排序（Bubble Sort）
- 时间O(n^2),空间O(1)
- 满足条件，交换相邻的两个数，每次循环就可以把当下序列最大的移到右边
- n个数，循环n-1趟，每趟，还剩（n-i）个数，所以需要（n-1-i）次比较
public void BubbleSort(int[] arr){
int n = arr.length;
for(int i = 1 ; i < n ; i--){
//一共要循环arr.length次
for(int j = 0 ; j < n-1-i ; j++){
//每次作n-1-i次交换判断
if (arr[j] > arr[j+1])
swap(arr,j,j+1);
}
}
}
选择排序（Selection Sort）
-
无论什么数据进去都是O(n^2)的时间复杂度
-
下标（i–>>n）中找到最小的min，和下标i交换
-
总共（n-1）趟，每趟还剩（n-i）个数，所以需要(n-1-i)次比较
-
（每次先令下标i为当前轮的min）
public static void BubbleSort(int[] arr){
int n = arr.length;
for(int i = 0 ; i < n-1 ; i++){
//一共要循环arr.length-1次
for(int j = 0 ; j < n-1-i ; j++){
//每次作n-1-i次交换判断
if (arr[j] > arr[j + 1])
swap(arr,j,j+1);
}
}
}
插入排序（Insertion Sort）
- 时间：O(n^2)，空间：只需用到O(1)的额外空间
- 从第二个元素开始，共（n-1）趟
- 每趟i元素逐个向前比较，直到遇到更小的停止
- 用临时变量tem保存arr[i]
public static void InsertionSort(int[] arr){
if(arr == null || arr.length < 2)
return;
int temp;//暂时保存arr[i]的值
int n = arr.length;
int i = 0;
int j = 0;
for(i = 1 ; i < n ; i++){
temp = arr[i];
for(j = i-1 ; j >= 0; j--){
if(arr[j] <= temp)
break;
arr[j+1]=arr[j];
//直接赋值，因为此时arr[i]已经被保存在temp里面了，免去了swap的繁琐。
}
arr[j+1] = temp;
}
}
快速排序（Quick Sort）
-
从数列中随机挑一个数作为基准，把他和最右侧数字进行交换
-
进入partition，
两个指针less，more
- less是小于区的边界所以，初始值为L-1
- more是大于区的边界，但此时基准值已经在最右侧大于区了，初始值为R
分三个区，三种情况
- 小于区，如果数字小于基准值，则和小于区外第一个数字做交换，扩充小于区
- 等于区，如果数字等于基准值，不动单纯L++（之后会被小于区的扩张自动推到中间）
- 大于区, 如果数字大于基准值，和大于区左侧的第一个数做交换，扩充大于区
-
最后交换more指针和R，(即把基准值放在大于区边缘)
public static void QuickSort(int[] arr){
if(arr.length<2)return;
Sort(arr,0,arr.length-1);
}
public static void Sort(int[] arr, int L, int R){
if(L<R){
swap(arr,L+(int) (Math.random()*(R-L+1)),R);
int[] range = Partition(arr,L,R);
Sort(arr,L,range[0]-1);
Sort(arr,range[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,R,more);
return new int[] {less+1,more};
}
堆排序（Heap Sort）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A0CW3WVE-1689069745089)(https://gitee.com/RainySigh/images/raw/yujie/20230711162800-31.gif)]
数据结构
- 父—i(i为下标元素)
- 左孩子:2i+1
- 右孩子:2*i+2;
- 子—i(i为下标元素)
- 父:(i-1)/2;
概念解析
- 每个结点的值都大于等于其左右孩子结点的值，称为大顶堆
- 每个结点的值都小于等于其左右孩子结点的值，称为小顶堆
原理步骤
-
将初始的数组可以看成一个完全二叉树
-
则第一步，将初始序列构建成大顶堆（结束时可得最大值必定在二叉树顶）
-
将栈顶元素R[1] 和最后一个元素交换，得到新序列
-
重新将新序列恢复成大顶堆
-
重复上述操作，直到有序区元素个数为n-1，排序过程完成
代码
- 堆排序
public static void heapSort(int[] arr){
if(arr==null || arr.length < 2){
return;
}
//将其调整为大顶堆
for(int i = 0; i < arr.length; i++){
heapInsert(arr,i); //O(logN)
}
//交换堆顶数字（最大值），和末尾元素
//则此时最大值，已经被放到了数字末尾
int heapSize = arr.length;
swap(arr, 0, --heapSize);
//重复上述过程，继续对余下的数字进行排序
while(heapSize>0){
heapify(arr, 0, heapSize);
swap(arr, 0, --heapSize);
}
}
- 从后往前构造堆
-
从最后一棵子树开始，从后往前调整
-
调整为大顶堆
//某个数处在index位置，继续往上移动 public static void heapInsert(int[] arr, int index){ while (arr[index] > arr[(index-1)/2]){ swap(arr, index, (index - 1)/2); index = (index - 1)/2； } }
- 从前往后构造堆
public static void heapify(int[] arr, int index, int heapSize){
int left = index * 2 + 1;
//如果下方还有孩子
while(left < heapSize){
//两个孩子中，谁的值大，谁把下标给largest
//只有右孩子在范围内，且比左值大的时候，才赋给largest
int largest = left + 1 < heapSize
&& arr[left + 1] > arr[left]
? left + 1 :left;
//父和孩子之间，谁的值大，就把下标给largest
largest = arr[largest] > arr[index] ? largest : index;
if(largest == index)break;
swap(arr,largest,index);
index = largest;
left = index * 2 + 1;
}
}
归并排序（Merge Sort）
-
采用分治法（Divide and Conquer）
-
MergeSort规则：
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
-
merge规则：
- 两段数组，两个指针，一个help数组临时存储
- 前后两个数组指针指向的数字，谁小谁放入help，指针后移
- 直到某一段数组的指针溢出，就把另一个全部存进help
public static void MergeSort(int[] arr){
int n = arr.length;
if(n < 2) return arr;
int L = 0;
int R = n-1;
Service(arr,L,R);
}
public void Sevice(int[] arr,int L,int R){
if(L==R) return;
int M = L+((R-L)>>1)
Service(arr,L,M);
Service(arr,M+1,R);
merge(arr,L,R);
}
public void merge(int[] arr,int L,int R){
int[] help = new int[R-L+1];
int M = (R+L)>>1;
int pl = L;
int pr = M+1;
int i = 0;
while(pl<=M && pr<=R) help[i++] = (arr[pl]>arr[pr]) ? arr[pr] : arr[pl];
while(pl<=M) help[i++]=arr[pl++];
while(pr<=R) help[i++]=arr[pr++];
int j = L;
for(int n : help)
arr[j++] = n;
}
小和，逆序对问题----归并排序的变种：
力扣同类型题链接
例题-小和问题
题目描述：
在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个给定数组的小和。
例子：
数组为：[1,3,4,2,5]
1左边比1小的数：没有
3左边比3小的数：1
4左边比4小的数：1,3
2左边比2小的数：1
5左边比5小的数：1,3,4,2
所以小和为1+(1+3)+1+(1+3+4+2)=16
解析
小和中，
1出现了四次，因为1右侧有四个比一大的数
3出现了两次，因为三右侧有两个比三大的数字
以此类推，可得
小和就是每个数字*其右侧比自身大的数字个数
为什么使用归并排序
- 在左组和右组merge的时候，会比较数的大小，
- 这时就可以在右组找到比左组当前数大的个数。
和经典的归并排序的区别
左右组相等的时候，要先拷贝右组的数字，且不产生小和
右组大于左组的时候，直接让小和加上左数*右组还剩下的个数（此时各组内都已经排好序了）；
具体代码
public static int SmallSum(int[] arr){
int L = 0;
int R = arr.length-1;
return Process(arr,L,R);
}
public static int Process(int[] arr, int L, int R){
if(R==L)return 0;
int M = L + ((R-L)>>1);
return
Process(arr,L,M)+Process(arr,M+1,R)+Merge(arr,L,M,R);
}
public static int Merge(int[] arr, int L, int M, int R){
int p1 = L;
int p2 = M+1;
int LittleSum = 0;
int[] help = new int[R-L+1];
int i = 0;
while(p1<=M&&p2<=R){
if(arr[p1]>=arr[p2])
help[i++] = arr[p2++];
else if(arr[p1]<arr[p2]){
LittleSum+=(arr[p1]*(R-p2+1));
help[i++] = arr[p1++];
}
}
while(p1<=M)
help[i++] = arr[p1++];
while(p2<=R)
help[i++] = arr[p2++];
i = 0;
for (int j = L; j <= R; j++) {
arr[j] = help[i++];
}
return LittleSum;
}
例题–逆序对问题
设有一个数组 [a1, a2, a3,… an]，对于数组中任意两个元素ai，aj，若i<j，ai>aj，则说明ai和aj是一对逆序对。求一个给定数组的逆序对个数。
扫一扫
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
