目录
概念
排序：一串记录，按照其中的某个或者某些关键字的大小，递增或者递减排列起来的操作。通常意义上的排序都是指原地排序。
什么是排序稳定性
排序稳定性：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，那么该算法是具备稳定性的排序。
排序的分类总览
1.插入排序
直接插入排序
原理
整个区间被分为
- 有序区间
- 无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入
代码实现
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--) {
//如果这里是>= 那就是不稳定排序
if (array[j]>tmp){
array[j+1] = array[j];
}else {
array[j+1] = tmp;
break;
}
}
array[j+1] = tmp;
}
}
性能分析
| 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|
| O(n^2) | O(1) | 稳定 |
折半插入排序
希尔排序
原理
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
代码实现
//希尔排序
public 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 {
array[j+gap] = tmp;
break;
}
}
array[j+gap] = tmp;
}
}
public static void shellSort(int [] array){
int [] drr = {5,3,1};
for (int i = 0; i <array.length ; i++) {
shell(array , i);
}
}
性能分析
| 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|
| O(n^2) | O(1) | 不稳定 |
2.选择排序
直接选择排序
原理
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。
具体的排序过程为：
- 将整个记录序列划分为有序区和无序区，初始时有序区为空，无序区含有待排序的所有记录
- 在无序区选择关键码最小的记录，将其与无序区中的第一个元，使得有序区扩展一个记录，同时无序区减少了一个记录
- 不断重复步骤 2，直到无序区只剩下一个记录为止
初始关键字：『 8，5，2，6，9，3，1，4，0，7 』
第一趟排序后：0，『5，2，6，9，3，1，4，8，7』第二趟排序后：0，1，『2，6，9，3，5，4，8，7』
第三趟排序后：0，1，2，『6，9，3，5，4，8，7』
第四趟排序后：0，1，2，3，『9，6，5，4，8，7』
第五趟排序后：0，1，2，3，4，『6，5，9，8，7』
第六趟排序后：0，1，2，3，4，5，『6，9，8，7』
第七趟排序后：0，1，2，3，4，5，6，『9，8，7』
第八趟排序后：0，1，2，3，4，5，6，7，『8，9』
第九趟排序后：0，1，2，3，4，5，6，7，8，『9』
结果： 『 0，1，2，3，4，5，6，7，8，9 』
代码实现
public static void selectSort(int [] array){
for (int i = 0; i < array.length - 1; i++) {
// 无序区间: [0, array.length - i)
// 有序区间: [array.length - i, array.length)
int max = 0;
for (int j = 1; j < array.length - i; j++) {
if (array[j] > array[max]) {
max = j;
}
}
int t = array[max];
array[max] = array[array.length - i - 1];
array[array.length - i - 1] = t;
}
}
性能分析
| 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|
| O(n^2) | O(1) | 不稳定 |
堆排序
原理
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意： 排升序要建大堆；排降序要建小堆。
代码实现
public void heapSort(){
int end = this.elem.length-1;
while (end > 0){
//end与第一个元素交换
int tmp = this.elem[0];
this.elem[0] = this.elem[end];
this.elem[end] = tmp;
//交换完成后进行重排
adjustDown(0,end);
//end向前移动
end--;
}
}
public void adjustDown(int parent,int len){
int child = 2*parent+1;
//child<len说明有左孩子 但不一定有右孩子
while (child<len){
//child+1<len说明有右孩子
if (child+1<len&&this.elem[child]<this.elem[child+1]){
child++;
}
//child一定是左右孩子的最大值下标
if(this.elem[child]>this.elem[parent]){
int tmp = this.elem[child];
this.elem[child] = this.elem[parent];
this.elem[parent] = tmp;
parent = child;
child = 2*parent+1;
}else {
//从最后一颗树开始 只要child《=parent 后续就不需要调整了
break;
}
}
}
性能分析
| 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|
| O(n * log(n)) | O(1) | 不稳定 |
3.交换排序
冒泡排序
原理
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序
代码实现
性能分析
| 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|
| O(n^2) | O(1) | 稳定 |
快速排序（重要）
原理
- 从待排序区间选择一个数，作为基准值(pivot)；
- Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
- 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。
代码实现
//找基准的函数
public static int pivot(int [] array,int start,int end){
int tmp = array[start];
while (start < end){
while (start < end && array[end]>=tmp){
end--;
}
array[start] = array[end];
//数据赋值给low
while (start < end && array[start]<=tmp){
start++;
}
array[end] = array[start];
}
//最后把基准值放在相遇的位置
array[start] = tmp;
return start;
}
//实现快速排序
public static void quick(int []array,int low,int high){
if (low < high){
int piv = pivot(array,low,high);
//分而治之 分左右两边 递归找基准数字
quick(array,low,piv-1);
quick(array,piv+1,high);
}
}
public static void quickSort(int [] array){
quick(array,0,array.length-1);
}
性能分析
| 时间复杂度 | 空间复杂度 | ||||
|---|---|---|---|---|---|
| 最好 | 平均 | 最坏 | 最好 | 平均 | 最坏 |
| O(n * log(n)) | O(n * log(n)) | O(n^2) | O(log(n)) | O(log(n)) | O(n) |
稳定性
不稳定
4.归并排序
归并排序
原理
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
代码实现
private static void merge(int[] array, int low, int mid, int high) {
int i = low;
int j = mid;
int length = high - low;
int[] extra = new int[length];
int k = 0;
// 选择小的放入 extra
while (i < mid && j < high) {
// 加入等于，保证稳定性
if (array[i] <= array[j]) {
extra[k++] = array[i++];
} else {
extra[k++] = array[j++];
}
}
// 将属于元素放入 extra
while (i < mid) {
extra[k++] = array[i++];
}
while (j < right) {
extra[k++] = array[j++];
}
// 从 extra 搬移回 array
for (int t = 0; t < length; t++) {
// 需要搬移回原位置，从 low 开始
array[low + t] = extra[t];
}
}
public static void mergeSort(int[] array) {
mergeSortInternal(array, 0, array.length);
}
// 待排序区间为 [low, high)
private static void mergeSortInternal(int[] array, int low, int high) {
if (low - 1 >= high) {
return;
}
int mid = (low + high) / 2;
mergeSortInternal(array, low, mid);
mergeSortInternal(array, mid, high);
merge(array, low, mid, high);
}
性能分析
| 时间复杂度 | 空间复杂度 | 稳定性 |
|---|---|---|
| O(n * log(n)) | O(n) | 稳定 |
海量数据排序
外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
- 先把文件切分成 200 份，每个 512 M
- 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
- 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了
5.排序总结
| 排序方法 | 最好 | 平均 | 最坏 | 空间复杂度 | 稳定性 |
|---|---|---|---|---|---|
| 冒泡排序 | 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 * 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) | 稳定 |
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
