一、插入排序
1、直接插入排序原理
整个区间被分为有序区间、 无序区间。每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。
2、实现代码
public static void insertSort(int[] array) {
for (int bound = 0; bound < array.length; bound++) {
//有序区间 [0, bound)
//无序区间 [cur, array.length)
int tmp = array[bound];//无序区间的第一个数
int cur = bound - 1;
// 不写 array[cur] == tmp 是保证排序的稳定性
for (; cur >= 0 && array[cur] > tmp; cur--) {
array[cur + 1] = array[cur];
}
array[cur + 1] = tmp;
}
}
3、性能分析
(1) 时间复杂度：最好情况下为 O(N)，平均情况下为 O(N^2)，最坏情况下为 O(N^2)
(2) 空间复杂度：O(1)
(3) 稳定性：稳定
注意：插入排序，初始数据越接近有序，时间效率越高。
二、希尔排序
1、原理
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成整数个组，所有距离为整数的记录分在同一组内，并对每一组内的记录进行排序。然后，取/2，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
(1) 希尔排序是对直接插入排序的优化。
(2) 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。
2、实现代码
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
insertSortGap(array,gap);
gap = gap / 2;
}
insertSortGap(array,1);
}
public static void insertSortGap(int[] array,int gap) {
for (int bound = 0; bound < array.length; bound = bound + gap) {
int tmp = array[bound];
int cur = bound - gap;
for (; cur >= 0 && array[cur] > tmp; cur = cur - gap) {
array[cur + gap] = array[cur];
}
array[cur + gap] = tmp;
}
}
3、性能分析
(1) 时间复杂度：最好情况下为 O(N)，平均情况下为 O(N^1.3)，最坏情况下为 O(N^2)
(2) 空间复杂度：O(1)
(3) 稳定性：不稳定
三、选择排序
1、直接选择排序原理
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。
2、实现代码
public static void selectSort(int[] array) {
for (int bound = 0; bound < array.length; bound++) {
// 无序区间: [0, array.length - bound)
// 有序区间: [array.length - bound, array.length)
for (int cur = bound + 1; cur < array.length; cur++) {
if(array[bound] > array[cur]) {
int tmp = array[bound];
array[bound] = array[cur];
array[cur] = tmp;
}
}
}
}
3、性能分析
(1) 时间复杂度：O(N^2)
(2) 空间复杂度：O(1)
(3) 稳定性：不稳定
四、冒泡排序
1、原理
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。
2、实现代码
public static void bubbleSort(int[] array) {
for (int bound = 0; bound < array.length - 1; bound++) {
// 相等不交换，保证稳定性
for (int cur = 0; cur < array.length - bound - 1; cur++) {
if (array[cur] > array[cur + 1]) {
int tmp = array[cur];
array[cur] = array[cur + 1];
array[cur + 1] = tmp;
}
}
}
}
3、性能分析
(1) 时间复杂度：最好情况下为 O(N)，平均情况下为 O(N^2)，最坏情况下为 O(N^2)
(2) 空间复杂度：O(1)
(3) 稳定性：稳定
五、堆排序
1、原理
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意：排升序要建大堆；排降序要建小堆。
2、代码实现
public static void heapSort(int[] array) {
createHeap(array);
for (int cur = 0; cur < array.length; cur++) {
// 交换前
// 无序区间: [0, array.length - cur)
// 有序区间: [array.length - cur, array.length)
swap(array,0,array.length - 1);
// 交换后
// 无序区间: [0, array.length - cur - 1)
// 有序区间: [array.length - cur - 1, array.length)
// 无序区间长度: array.length - cur - 1
shiftDown(array,array.length - cur -1,0);
}
}
public static void createHeap(int[] array) {
for (int i = (array.length -1 -1 ) / 2; i >= 0 ; i--) {
shiftDown(array,array.length,i);
}
}
public static void shiftDown(int[] array, int size ,int index) {
int parent = index;
int child = 2*parent + 1;
while (child < size) {
if (child + 1 < size && array[child] < array[child + 1]) {
child = child + 1;
}
if(array[parent] < array[child]) {
swap(array,parent,child);
}else {
break;
}
parent = child;
child = 2*parent + 1;
}
}
3、性能分析
(1) 时间复杂度：O( N * log(N) )
(2) 空间复杂度：O(1)
(3) 稳定性：不稳定
六、快速排序
1、原理
(1) 从待排序区间选择一个数，作为基准值(pivot)
(2) Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边
(3) 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据
2、实现代码
public static void quickSort(int[] array) {
quickSortHelper(array,0,array.length-1);
}
// [left, right] 为待排序区间
private static void quickSortHelper(int[] array, int left, int right) {
if (left >= right) {
return;
}
// 最简单的选择基准值的方式，选择 array[right] 作为基准值
// index 代表基准值最终停留的下标
int index = partition(array,left,right);
// [left, index - 1] 都是小于等于基准值的
// [index + 1, right] 都是大于等于基准值的
quickSortHelper(array, left, index - 1);
quickSortHelper(array, index + 1, right);
}
private static int partition(int[] array, int left, int right) {
int cur1 = left;
int cur2 = right;
int pivot = array[right];
while (cur1 < cur2) {
while (cur1 < cur2 && array[cur1] <= pivot) {
cur1++;
}
while (cur1 < cur2 && array[cur2] >= pivot) {
cur2--;
}
if(cur1 < cur2) {
swap(array,cur1,cur2);
}
}
swap(array,cur1,right);
return cur1;
}
3、性能分析
(1) 时间复杂度：最好情况下为 O( N * log(N) )，平均情况下 O( N * log(N) )，最坏情况下 O(N^2)
(2) 空间复杂度：最好情况下为 O( log(N) )，平均情况下 O( log(N) )，最坏情况下 O(N)
(3) 稳定性：不稳定
4、优化
(1) 选择基准值很重要，通常使用几数取中法
(2) partition 过程中把和基准值相等的数也选择出来
(3) 待排序区间小于一个阈值时，使用直接插入排序
七、归并排序
1、原理——（合并两个有序数组）
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
2、代码实现
public static void mergeSort(int[] array) {
mergeSortHelper(array,0,array.length);
}
//待排区间为[left,right)
private static void mergeSortHelper(int[] array, int left ,int right) {
if (right - left <= 1) {
return;
}
int mid = (right + left) / 2;
mergeSortHelper(array, left, mid);
mergeSortHelper(array, mid, right);
merge(array, left, mid, right);
}
private static void merge(int[] array, int left, int mid ,int right) {
int cur1 = left;
int cur2 = mid;
int[] output = new int[right - left];
int index = 0;
//选择小的放入 output
while (cur1 < mid && cur2 < right) {
//等号保证稳定性
if(array[cur1] <= array[cur2]) {
output[index] = array[cur1];
index++;
cur1++;
}else {
output[index] = array[cur2];
index++;
cur2++;
}
}
//将剩余元素放入 output
while (cur1 < mid) {
output[index] = array[cur1];
index++;
cur1++;
}
while (cur2 < right) {
output[index] = array[cur2];
index++;
cur2++;
}
//从 output 搬运到 array
for (int i = 0; i < right - left; i++) {
//需要搬回原位置，从 left 开始
array[left + i] = output[i];
}
}
3、性能分析
(1) 时间复杂度：O( N * log(N) )
(2) 空间复杂度： O(N)
(3) 稳定性：稳定
4、优化
在排序过程中重复利用两个数组，减少元素的复制过程
扫一扫
833
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
