概念
排序
排序，就是使一串记录，按照其中的某个或者某些关键字的大笑，递增或递减的排列起来的操作。
平时的上下文中，如果提到排序，通常意义上的排序，都是指的原地排序（in place sort）。
稳定性（重要）
两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。
七大基于比较的排序
插入排序
直接插入排序的原理
整个区间被分为：有序区间，无序区间
每次选择无序区间的第一个元素，再有序区间选择和合适的位置插入
实现
public static void insertSort(int[] array){
for(int i = 1; i < array.length;i++){
// 有序区间：[0, i)
// 无序区间：[i, array.length)
int v = array[i]; //无序区间的第一个数
int j = i -1;
// 不写 array[j] == v 是保证排序的稳定性
for(;j >= 0; array[j] > v; j--){
array[j + 1] = array[j];
}
array[j + 1] = v;
}
}
性能分析
希尔排序
原理
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比
实现
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
insertSortGap(array, gap);
gap = (gap / 3) + 1; // OR gap = gap / 2;
}
insertSortGap(array, 1);
}
private static void insertSortGap(int[] array, int gap) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int j = i - gap;
for (; j >= 0 && array[j] > v; j -= gap) {
array[j + gap] = array[j];
}
array[j + gap] = v;
}
}
性能分析
选择排序
直接选择排序原理
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完。
实现
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)
//最坏的时间复杂度为O(n^2)
//空间复杂度为O(1)
//是一个稳定的排序
public static void adjustDown(int[] array,int root,int len){
int parent = root ;
int child = 2*parent + 1;
while(child < len){
if(child+1<len&&array[child] < array[child+1]){
child++;
}
//child保存的是最大值的下标
if(array[child] > array[parent]){
int tmp = array[child];
array[child] = array[parent];
array[parent] = tmp;
parent = child;
child = 2*parent + 1;
}else{
break;
}
}
}
public static void createHeap(int[] array){
for(int i = (array.length -1-1)/2; i>=0 ; i--){
adjustDown(array,1,array.length);
}
}
/**
* 时间复杂度为：n*log2n
* 空间复杂度：O(1)
* 建堆的时间复杂度：n*log2n
* 一次调整的时间复杂度：log2n
* 稳定性：不稳定的排序算法
* @param array
*/
public static void heapSort(int[] array){
createHeap(array);
int end = array.length-1;
while(end > 0){
int tmp = array[end];
array[end] = array[0];
array[0] = tmp;
adjustDown(array,0,end);
end--;
}
}
性能分析
冒泡排序
原理
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序
实现
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean isSorted = true;
for (int j = 0; j < array.length - i - 1; j++) { // 相等不交换，保证稳定性
if (array[j] > array[j + 1]) {
swap(array, j, j + 1);
isSorted = false;
}
}
if (isSorted) {
break;
}
}
}
性能分析
快速排序
原理
1.从待排序区间选择一个数，作为基准值（pivot）;
2.Partition:遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准小的（可以包含相等的）放到基准值的右边；
3.采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。
实现：
public static void quickSort(int[] array) {
quickSortInternal(array, 0, array.length - 1);
}
// [left, right] 为待排序区间
private static void quickSortInternal(int[] array, int left, int right) {
if (left == right) {
return;
}
if (left > right) {
return;
}
// 最简单的选择基准值的方式，选择 array[left] 作为基准值
// pivotIndex 代表基准值最终停留的下标
int pivotIndex = partition(array, left, right);
// [left, pivotIndex - 1] 都是小于等于基准值的
// [pivotIndex + 1, right] 都是大于等于基准值的
quickSortInternal(array, left, pivotIndex - 1);
quickSortInternal(array, pivotIndex + 1, right);
}
原理
Hoare法：
实现
private static int partition(int array, int left, int rigth){
int i = left;
int j = right;
while(i < j){
while(i<j && array[j] >= pivot){
j--;
}
while(i<j && array[i] <= pivot){
i++;
}
swap(array,i,j);
}
swap(array, i, left);
return i;
}
挖坑法：
基本思路和Hoare法一致，只要不再进行交换，而是进行赋值（填坑+挖坑）
实现
private static int partition(int[] array, int left, int right){
int i = left;
int j = right;
int pivot = array[left];
while(i<j){
while(i < j && array[i] >= pivot){
j--;
}
array[i] = array[j];
while(i<j && array[i] <= pivot){
i++;
}
array[j] = array[i];
}
array[i] = pivot;
return i;
}
前后遍历法
private static int partition(int[] array, int left, int rigth){
int d = left + 1;
int pivot = array[left]; ``
for(int i = left + 1; i <= right; i++){
if(array[i] < pivot){
swap(array, i, d);
d++;
}
}
swap(array, d - 1; left);
return d-1;
}
性能分析
原理-基准值的选择
1、选择边上（左或者右）
2、随机选择
3、几数取中（例如三数取中）：array[left], array[mid], array[right]大小是中间的为基准值。
原理-非递归分治
public static void quickSort(int[] array){
Stack<Integer> stack = new Stack<>();
stack.push(array.length - 1);
stack.push(0);
while(!stack.isEmpty()){
int left = stack.pop();
int right = stack.pop();
if(left >= right){
continue;
}
int pivotIndex = partition(array, left, right);
stack.push(right);
stack.push(pivotIndex + 1);
stack.push(pivotIndex - 1);
stack.push(left);
}
}
优化总结
1、选择基准很重要，通常使用几数取中法；
2、partition 过程中把和基准值相等的数也选择出来；
3、待排序区间小于一个阈值时（例如48），使用直接插入排序。
总结
- 在待排序区间选择一个基准值
1. 选择左边或者右边
2. 随机选取
3. 几数取中法 - 做 partition，使得小的数在左，大的数在右
1. hoare
2. 挖坑
3. 前后遍历
4. 将基准值相等的也选择出来（了解） - 分治处理左右两个小区间，直到小区间数目小于一个阈值，使用插入排序
归并排序
原理
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
原理-合并两个有序数组
private static void merge(int[] array, 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[i]){
extra[k++] = array[i++];
} else {
extra[k++] = array[j++];
}
}
//将属于元素放入 extra
while (j < high){
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 >= high - 1){
return;
}
int mid = (low + high)/2;
mergeSortInternal(array, low, mid);
mergeSortInternal(array, mid, high);
merge(array, low, mid, high);
}
性能分析
优化总结
在排序过程中重复利用两个数组，减少元素的复制过程
非递归版本
public static void mergeSort(int[] array){
for(int i = 1; i < array.length; i = i*2){
for(int j = 0; j < array.length; j = j+2*i){
int low = j;
int mid = j + i;
if(mid >= array.length){
continue;
}
int high = mid + i;
if(high > array.length){
high = array.length;
}
merge(array, low, mid, high);
}
}
}
海量数据的排序问题
外部排序：排序过程需要在磁盘等外部存储进行的排序。
前提：内存只有1G，需要排序的数据有100G；
因为内存中无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
1. 先把文件切分成200份，每个512M；
2. 分别对512M排序，因为内存已经可以放得下，所以任意排序方式都可以。
3. 进行200路归并，同时对200份有序文件做归并过程，最终结果就有序了。
排序总结
3730
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
