插入排序
1.直接插入排序
动图传送门.
思想： 类比打扑克时，一张张揭牌并从后向前找到插入位置，让手中的牌永远为有序状态
// 1.直接插入
public static void insertSort(int[] array) {
// 1.一张张揭牌，手中的牌一直是有序的
for (int i = 1; i < array.length; i++) {
// 揭到第 i 张牌
int curNum = array[i];
// 2.向前寻找可插入的地方
int j = i - 1;
while (j >= 0 && curNum < array[j]) {
// 还没有到插入的位置，第j位置向后移动，留出空位
array[j + 1] = array[j];
j --;
}
// 3.插入揭到的牌
array[j + 1] = curNum;
}
}
时间复杂度：
| 时间复杂度 | 平均：O(n^2) | 最好（有序时）：O(n) | 最坏（逆序时）：O(n^2) |
|---|---|---|---|
| 空间复杂度：O(1) | |||
| 稳定性：稳定 | |||
| 优化：折半查找，先用折半查找到队对应位置，再搬移 |
2.希尔排序
图解：
思想： 直接插入排序在有序时时间复杂度为 O(n)，希尔排序的思想是先让数组趋于有序，再进行直接插入排序。
具体做法：把待排序数组中所有距离为 n 的数记录分在同一组内，并对每一组内的记录进行排序。这样距离为 n 的数边为有序，再缩小 n 值重复上述操作，整个数组逐渐趋于有序，最后 n = 1时，也就是直接插入排序。
// 2.希尔排序
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 0) {
insertSortGap(array, gap);
// 缩小增量公式
gap = gap /3 + 1;
}
// 此时数组已经趋于有序， gap = 1 时，相当于直接插入排序
insertSortGap(array,1);
}
private static void insertSortGap(int[] array, int gap) {
// 对 array 中相隔 gap 的数进行排序，类比直接插入排序
for (int i = gap; i < array.length; i += gap) {
int curNum = array[i];
int j = i - gap;
while (j >= 0 && curNum < array[j]) {
array[j + gap] = array[j];
j -= gap;
}
array[j + gap] = curNum;
}
}
时间复杂度：
| 时间复杂度 | 平均：O(n^1.3) | 最好：O(n) | 最坏：O(n^2) |
|---|---|---|---|
| 空间复杂度：O(1) | |||
| 稳定性：不稳定 |
选择排序
3.直接选择排序
思想：每轮从无序区间选择最小的数交换到最前边
// 3.直接选择排序
public static void selectSort(int[] array) {
// 从无序区间选择最小数交换到最无序区间的最前边 有序区间[0,i) 无序区间[i,len]
for (int i = 0; i < array.length; i++) {
int minIndex = i;
// 寻找最小值下标
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
// 找到后，交换位置
int tmp = array[i];
array[i] = array[minIndex];
array[minIndex] = tmp;
}
}
时间复杂度：每轮都要从头到尾遍历，对数据不敏感，O(n^2)
空间复杂度： O(1)
稳定性：不稳定
优化：双向选择排序，每次从无序区间找出最大和最小的元素放到最前和最后
4.堆排序
动画演示.
思想：同直接选择排序，只是不在使用每轮遍历查找无序区间的最小数放在最前边，而是通过创建大根堆每轮来选择最大值（堆顶的数）放在最后边
注意： 排升序要建大堆；排降序要建小堆
// 4.堆排
public static void heapSort(int[] array) {
// 1.创建大根堆
int end = array.length - 1;
for (int i = (end - 1) / 2; i >= 0 ; i--) {
// 从最后一个非子叶结点开始向下调整
adjustDown(array, i, end);
}
// 2. 选择最大数交换位置
while (end > 0) {
// 将最大数换到最后边
swap(array, 0, end);
// 缩小无序区间
end --;
//再向下调整
adjustDown(array, 0, end);
}
}
// 向下调整：调整为父亲结点值大于子结点，在找到最大子结点后与父亲结点对比交换
private static void adjustDown(int[] array, int parent, int end) {
// 默认最大子结点
int child = 2 * parent + 1;
// 有可能要调整的父亲结点是个很小的数，与最大子结点交换后依然小于子结点，还需继续调整。所以要 while 循环里，直到大于子结点或者没有子结点结束循环
while (child <= end) {
// 如果存在右孩子，并且右孩子大于左孩子，更新最大孩子结点
if (child + 1 <= end && array[child + 1] > array[child]) {
child += 1;
}
// 此时的 child 已经为为最大子结点
if (array[child] > array[parent]) {
// 如果最大孩子结点大于父亲结点，交换
swap(array, child, parent);
// 从子结点开始下一轮调整
parent = child;
child = 2 * parent + 1;
} else {
// 大于子结点，跳出循环
break;
}
}
}
// 交换位置
private static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
时间复杂度：O(logn)
空间复杂度：O(1)
稳定性：不稳定
交换排序
5.冒泡排序
思想：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后
// 5.冒泡排序
public static void bubbleSort(int[] array) {
// 无序区间[0，len-i], i表示有序区间 数的个数
for (int i = 0; i < array.length; i++) {
// 遍历无序区间
for (int j = 0; j < array.length - i - 1; j++) {
// 对比交换相邻两个数较大的数
if (array[j] > array[j + 1]) {
// 交换位置
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
}
}
时间复杂度：O(n^2)
空间复杂度： O(1)
稳定性：稳定
6.快排
思想：选定一个数作为基准，一轮遍历确定基准数位置（数组有序后基准的位置），并保证左边全是小于基准数，右边全是大于基准数，再对基准数两边进行同样的操作。即每轮将待排序区间分割为大小两个区间，中间的分割点就是基准数。
// 6.快排
public static void quickSort(int[] array) {
quick(array, 0, array.length - 1);
}
// 递归
private static void quick(int[] array, int low, int high) {
// 结束条件
if (low >= high) return;
// 确定大小两区间的 分割点
int piv = pivot(array, low, high);
// 对两边区间递归
quick(array, low, piv - 1);
quick(array, piv + 1, high);
}
// 划分大小区间，并返回分割点下标
private static int pivot(int[] array, int start, int end) {
// 将待排序区间的首位 确定为基准数
int piv = array[start];
// 开始寻找基准数该在的位置
while (start < end) {
// 从右开始找小于基准数的数
while (start < end && array[end] >= piv) {
end --;
}
// 放在前边，因为小于基准数的数不应该出现在基准数之后
array[start] = array[end];
// 从左开始找大于基准数的数
while (start < end && array[start] <= piv) {
start ++;
}
// 放在后边，因为大于基准数的数不应该出现在基准数之前
array[end] = array[start];
}
// 左右指针相遇位置，就是数组有序后基准数应该在的位置。因为上边一轮交换后，该位置左边全都小于基准数，右边全大于基准数
array[end] = piv;
// 返回基准数应该在的位置，及数组有序后基准数在的位置
return end;
}
时间复杂度：
| 时间复杂度 | 平均：O(n * log(n)) | 最好（均匀划分）：O(n * log(n)) | 最坏(有序的情况)：O(n^2) |
|---|---|---|---|
| 若均匀划分，递归 logn 层你，每次遍历 n 个数，故时间复杂度为 O(nlogn)，若有序，则基准位置不需要动，每次都会以第一个位置划分区间，相当于没有划分区间，需要递归 n层，故 时间复杂度为 O(n^2)。 |
空间复杂度：
| 时间复杂度 | 平均：O(log(n)) | 最好（均匀划分）：O(log(n)) | 最坏(有序的情况)：O(n) |
|---|---|---|---|
| 原因同上，同递归的层数。 |
稳定性： 不稳定
优化： 以更均匀的划分区间为目的
- 随机选取基准
- 三数取中法：选3个数（最左、最右、中间）把中间大小的数和第一个数交换
归并排序
7.归并排序
图解：
思想：如果数组只有一个数，那么肯定有序。归并排序，先将数组分解为最小子序列，再俩俩合并，将问题转化为合并两个有序序列。这里同快排都用到了 分治思想（先放个连接回头聊）.
// 7.归并排序
public static void mergeSort(int[] array) {
mergeSortInternal(array, 0, array.length - 1);
}
// 递归
private static void mergeSortInternal(int[] array, int low, int high) {
// 结束条件
if (low >= high) return;
int mid = (low + high) / 2;
// 递归左右两部分
mergeSortInternal(array, low, mid);
mergeSortInternal(array, mid + 1, high);
// 合并
merge(array, low, mid, high);
}
// 合并两个有序数组 数组1：[low, mid] 数组2：[mid+1, high]
private static void merge(int[] array, int low, int mid, int high) {
// 两个区间的起始位置
int s1 = low;
int s2 = mid + 1;
// 归并结果接受数组
int tmp[] = new int[high - low + 1];
int k = 0;
// s1 和 s2都不出界时，对比较小的数放在前边
while (s1 <= mid && s2 <= high) {
if (array[s1] <= array[s2]) {
tmp[k++] = array[s1++];
}
if (array[s2] <= array[s1]) {
tmp[k++] = array[s2++];
}
}
// 两个区间剩余部分，添加到后边即可
while (s1 <= mid) {
tmp[k++] = array[s1++];
}
while (s2 <= high) {
tmp[k++] = array[s2++];
}
// 拷贝回原数组
for (int i = 0; i < tmp.length; i++) {
// 注意拷贝的区间是 low 开始
array[low + i] = tmp[i];
}
}
归并排序对数据不敏感，时间复杂度和空间复杂度固定不变
时间复杂度：类比快排，O(n * log(n))
空间复杂度： O(n)
稳定性：稳定
归并排序时间复杂度和快排相似，空间复杂度又不如快排，归并排序就不如快排吗？
非也，归并排序可用于解决海量数据的排序问题（外部排序）
场景：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序
- 先把文件切分成 200 份，每个 512 M
- 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
- 进行 200 路归并，同时对 200 份有序文件做归并过程，最终结果就有序了
稳定性
两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算
法。
快排和归并排序的非递归实现
快排：
public static void quickSort2(int[] array) {
Stack<Integer> stack = new Stack<>();
int low = 0;
int high = array.length - 1;
int piv = pivot(array, low, high);
if (piv > low + 1) { //判断左边至少有两个元素
stack.push(low);
stack.push(piv - 1);
}
if (piv < high - 1) {
stack.push(piv + 1);
stack.push(high);
}
while (!stack.empty()) {
high = stack.pop();
low = stack.pop();
piv = pivot(array, low, high);
if (piv > low + 1) {
stack.push(low);
stack.push(piv - 1);
}
if (piv < high - 1) {
stack.push(piv + 1);
stack.push(high);
}
}
}
归并排序：
public static void mergeSort1(int[] array) {
for (int i = 1; i < array.length; i *= 2) {
merge1(array, i);
}
}
private static void merge1(int[] array, int gap) {
int s1 = 0;
int e1 = s1 + gap - 1;
int s2 = e1 + 1;
int e2 = s2 + gap - 1 < array.length ? s2 + gap - 1 : array.length - 1; // 防止越界
int[] tmp = new int[array.length];
int k = 0;
while (s2 < array.length) { // 有两个归并段
while (s1 <= e1 && s2 <= e2) {
if (array[s1] <= array[s2]) {
tmp[k++] = array[s1++];
}
if (array[s2] <= array[s1]) {
tmp[k++] = array[s2++];
}
}
while (s1 <= e1) {
tmp[k++] = array[s1++];
}
while (s2 <= e2) {
tmp[k++] = array[s2++];
}
s1 = e2 + 1;
e1 = s1 + gap - 1;
s2 = e1 + 1;
e2 = s2 + gap - 1 < array.length ? s2 + gap - 1 : array.length - 1;
}
while (s1 < array.length) {
tmp[k++] = array[s1++];
}
for (int i = 0; i < tmp.length; i++) {
array[i] = tmp[i];
}
}
扫一扫
9146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
