目录
总览
稳定性
排序中，我们需要考虑每种排序是否稳定，那么什么叫做稳定性呢？
举个例子，下面有组数据，经过排序后的状态：
这张图就说明了什么叫排序的稳定：相等数据排序后在原来的位置即稳定
注：一个稳定的排序可以变为不稳定的排序，但是不稳定的排序不能变为稳定排序
七大排序
一、直接插入排序
思路：每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入
实现代码：
public static void insertSort(int[] arr){
for (int i = 1; i < arr.length; i++){
//取出每个元素来判断
int tmp = arr[i];
int j = i - 1;
//将tmp前的元素都进行比较
for (; j >= 0; j--){
if (arr[j] > tmp){
//大的往右移
arr[j + 1] = arr[j];
}else {
//到小的就退出
break;
}
}
//此时j+1的位置就是插入位置
arr[j + 1] = tmp;
}
}时间复杂度：O(N * 2)，但是数组越有序，插入排序会越快，最快O(N)。
空间复杂度：O(1)
稳定性：稳定。
二、希尔排序
思路：希尔排序本质就是对直接插入排序的优化，对一组数据分组进行插入排序，如动画：
不断缩小分组变量，最终分组变量一定变为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 {
break;
}
}
array[j + gap] = tmp;
}
}
public static void shellSort(int[] array){
int gap = array.length;
while (gap > 1){
shell(array, gap);
gap /= 2;
}
//最后一次分组变量为1
shell(array, 1);
}时间复杂度：O(N^1.3 - N^1.5)
空间复杂度：O(1)
稳定性：不稳定。
三、选择排序
思路：i 从0不断遍历，找到 i+1 往后最小的值与 i 下标交换，如动画：
实现代码：
//普通的选择排序：找到小的就交换
public static void selectSort1(int[] array){
for (int i = 0; i < array.length; i++){
for (int j = i + 1; j < array.length; j++){
if (array[j] < array[i]){
int tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
}
}
}
//优化后的选择排序：找到最小的交换
public static void selectSort(int[] array){
for (int i = 0; i < array.length; i++){
int min = i; //i之前都排好序了
for (int j = i + 1; j < array.length; j++){
if (array[j] < array[min]){
min = j;
}
}
int tmp = array[i];
array[i] = array[min];
array[min] = tmp;
}
}时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：不稳定。
四、堆排序
思路：详见此文章
实现代码：
public static void heapSort(int[] array){
//创建堆时间复杂度是O(N)
createHeap(array);
int end = array.length - 1;
while (end > 0){
//遍历并调整时间复杂度为O(N * logN)
int tmp = array[0];
array[0] = array[end];
array[end] = tmp;
shiftDown(array, 0, end);
end--;
}
}
public static void createHeap(int[] array){
for (int parent = (array.length-1-1)/2; parent >= 0; parent--){
shiftDown(array, parent, array.length);
}
}
public static void shiftDown(int[] array, int parent, int len){
int child = parent * 2 + 1;
while (child < len){
//有没有右孩子，右孩子大不大
if (child + 1 < len && array[child + 1] > array[child]){
child++;
}
//判断要不要父子交换
if (array[parent] < array[child]){
int tmp = array[child];
array[child] = array[parent];
array[parent] = tmp;
//换完parent到child位置
parent = child;
child = parent * 2 + 1;
}else {
break;
}
}
}时间复杂度：O(N * logN)
空间复杂度：O(1)
稳定性：不稳定。
五、冒泡排序
思路：冒泡排序本质就是前后比较再交换，最后把大的放在末尾
所以重点就在 i 和 j 的边界，i 表示趟数，j 表示每趟比较次数
这里有个优化：当遍历一次没有交换，证明已经有序了。
实现代码：
public static void bubbleSort(int[] array){
//i代表趟数
for (int i = 0; i < array.length - 1; i++){
boolean flg = false;//优化
//j代表每趟比较次数
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;
flg = true;
}
}
//如果flg是false证明没有交换，说明已经有序了
if (!flg){
break;
}
}
}时间复杂度：O(N^2)，优化后最好情况为O(N)
空间复杂度：O(1)
稳定性：稳定。
六、快速排序
思路：快速排序需要找到一个基准pivot，基准值左边都比基准值小，右边都比它大，如动画：
然后再对左右两个小区间进行同样方式即可
（这里找基准单独写一个方法：partition()，并且在缩小区间我们可以采用递归的方式）
实现代码：
public static void quickSort(int[] array){
quick(array, 0, array.length - 1);
}
public static void quick(int[] array, int left, int right){
//结束递归条件
if (left >= right){
return;
}
//找到基准
int pivot = partition(array, left, right);
//递归左边
quick(array, left, pivot - 1);
//递归右边
quick(array, pivot + 1, right);
}
public static int partition(int[] array, int start, int end){
//挖坑法：
int tmp = array[start];
while (start < end){
//找到右边比tmp小的(等于如果不加，会重复赋值，导致死循环)
while (start < end && array[end] >= tmp){
end--;
}
//找到小的就放过去
array[start] = array[end];
//找到左边比tmp大的
while (start < end && array[start] <= tmp){
start++;
}
array[end] = array[start];
}
//start和end相遇后别忘了把最后的tmp赋值过来
array[start] = tmp;
return start;
}时间复杂度：O(N*logN)，最坏情况下（有序或逆序）会达到O(N ^ 2)
（递归可以想象为树，树每层都要遍历N次去找基准，一共要树的高度次（logN））
空间复杂度：O(logN)（树的高度），最坏同上，会形成单分支的树，达到O(N)
稳定性：不稳定。
优化：由于数组有序时时间复杂度会达到O(N ^ 2)，所以可以在找基准时优化
有以下几种方式：
- 随机选择基准值：但是这种并不靠谱
- 三数取中法：这种最常用，已知 left 和 right，再取它们的中间值，找到这三个值中中间大的
public static void quick(int[] array, int left, int right){
if (left >= right){
return;
}
//三数取中法找基准
int midIndex = findMid(array, left, right);
//把找到的基准放开头
int tmp = array[left];
array[left] = array[tmp];
array[tmp] = array[left];
int pivot = partition(array, left, right);
quick(array, left, pivot - 1);
quick(array, pivot + 1, right);
}
public static int findMid(int[] array, int left, int right){
int mid = left + (right - left) / 2;
if (array[left] > array[right]){
if (array[left] < array[mid]){
return left;
}else {
if (array[right] > array[mid]){
return right;
}else {
return mid;
}
}
}else {
if (array[left] > array[mid]){
return left;
}else {
if (array[right] < array[mid]){
return right;
}else {
return mid;
}
}
}
}- 如果遇到基准的相同值，可以把相同值都放在基准旁，减小左右递归区间
- 利用直接插入排序，利用它越有序越快的特点，在缩小区间到一定值后，直接用插入排序
(这里的直接插入排序需要框定一个区间)
public static void insertSort1(int[] arr,int left, int right){
for (int i = left + 1; i <= right; i++){
int tmp = arr[i];
int j = i - 1;
for (; j >= left; j--){
if (arr[j] > tmp){
arr[j + 1] = arr[j];
}else {
break;
}
}
arr[j + 1] = tmp;
}
}
public static void quick(int[] array, int left, int right){
//结束递归条件
if (left >= right){
return;
}
//如果区间缩小到一定值可以直接用插入排序
if (right - left + 1 <= 30){
insertSort1(array, left, right);
return;
}
//找到基准
int pivot = partition(array, left, right);
//递归左边
quick(array, left, pivot - 1);
//递归右边
quick(array, pivot + 1, right);
}最后，写一个非递归版本的快速排序：
public static void quickSort1(int[] array){
//递归的本质就是用栈，这里我们用栈来写
//划分之后，把左右数对放入栈中，此时还要判断是不是pivot左右只剩下一个元素
Stack<Integer> stack = new Stack<>();
int left = 0;
int right = array.length - 1;
int pivot = partition(array, left, right);//先找到一个基准
if (pivot > left + 1){
//左边数大于两个
stack.push(left);
stack.push(pivot - 1);
}
if (pivot < right - 1){
//右边数大于两个
stack.push(pivot + 1);
stack.push(right);
}
while (!stack.isEmpty()){
right = stack.pop();
left = stack.pop();
pivot = partition(array, left, right);
if (pivot > left + 1){
//左边数大于两个
stack.push(left);
stack.push(pivot - 1);
}
if (pivot < right - 1){
//右边数大于两个
stack.push(pivot + 1);
stack.push(right);
}
}
}
七、归并排序
思路：将一个数组分组再合并，合并的方法是将两个有序数组变为一个有序数组，如图：
实现代码：代码的分解思想如下：
合并通过 l、m、r 的关系创建一个新的有序数组，最后再放回原数组即可
public static void mergeSort(int[] array){
mergeSortInternal(array, 0, array.length - 1);
}
//先分解左边，再分解右边，最后合并
public static void mergeSortInternal(int[] array, int left, int right){
//递归结束条件即分解成一个数，此时左边=右边
if (left >= right){
return;
}
int mid = left + (right - left) / 2;
//左边
mergeSortInternal(array, left, mid);
//右边
mergeSortInternal(array, mid + 1, right);
//合并
merge(array, left, mid, right);
}
//合并两个有序数组
public static void merge(int[] array, int left, int mid, int right){
int s1 = left;
int e1 = mid;
int s2 = mid + 1;
int e2 = right;
int k = 0;
int[] ans = new int[right - left + 1];
while (s1 <= e1 && s2 <= e2){
if (array[s1] <= array[s2]){//这里 '=' 不加就不稳定了
ans[k++] = array[s1++];
}else {
ans[k++] = array[s2++];
}
}
//第一个数组还有元素
while (s1 <= e1){
ans[k++] = array[s1++];
}
//第二个数组还有元素
while (s2 <= e2){
ans[k++] = array[s2++];
}
//将ans中的元素放入array中
for (int i = 0; i < ans.length; i++) {
array[i + left] = ans[i];
}
}时间复杂度：O(N * logN), 因为每层都有n个数，有logN层（高度）
空间复杂度：O(N)，因为申请了一个和原数组一样大的tmp数组。
稳定性：稳定
非递归版本：
public static void mergeSort1(int[] array){
//nums代表组内元素个数
int nums = 1;
while (nums < array.length){//组内有数组长度证明结束分组
//两个两个有序，所以 i 乘以组内元素的双倍
for (int i = 0; i < array.length; i += nums * 2){
//这里left、mid、right要重点记住
int left = i;
int mid = left + nums - 1;
//防止越界,因为left可能走到了最后
if (mid >= array.length){
mid = array.length - 1;
}
int right = nums + mid;
if (right >= array.length){
right = array.length - 1;
}
merge(array, left, mid, right);
}
nums *= 2;
}
}
总结
谢谢你能看到这✍
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
