内事不决问张昭，外事不决问周瑜，“ 排序 ”不决问威少_张昭处理外事

最新推荐文章于 2025-04-27 22:48:25 发布

2301_82241698

最新推荐文章于 2025-04-27 22:48:25 发布

阅读量344

点赞数 3

分类专栏： 2024年程序员学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_82241698/article/details/137896828

版权

2024年程序员学习专栏收录该内容

63 篇文章

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

//堆排序
public static void heapSort(int[] array){
creayHeap(array);
int end = array.length-1;
while(end > 0){
int temp = array[0];
array[0] = array[end];
array[end] = temp;
end–;
adjustDown(array,0,end);
}
}


用Java类建一个堆，好写，不过md这个时间复杂度比较高

//调用一个堆
public static void heapSort(int[] array){
PriorityQueue minHeap = new PriorityQueue<>();
for (int i = 0; i < array.length; i++) {
minHeap.offer(array[i]);
}
int i = 0;
while(!minHeap.isEmpty()){
array[i] = minHeap.poll();
i++;
}
}


## 六、快速排序


**中心思想：Partition和分治**


* 从待排序区间里选一个数，作为基准值（pivot）
* Partition：遍历整个区间，将比基准值小的放到基准值的左边，将比基准值大的放到基准值的右边
* **分治思想**，对左右两个小区间按照同样的方式处理，知道小区间的长度为1，代表已经有序；或小区间的长度为0，代表没有数据


### Partition


#### 挖坑法实现Partition


**中心思想：右填左坑，左填右坑**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/19d7df77ec474605a51a7755d065296f.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)


* 找一个元素作为基准（pivot）（此处是第一个元素作基准）
* low下标从左边开始遍历，high下标从右边开始遍历，low和high就是“坑”
* 首先low下标作为“坑”，需要比 pivot 小的元素填坑，high–，找到比pivot 小的元素，赋值给low
* 然后high下标作为“坑”，需要比pivot 大的元素填坑，low++，找到比pivot 大的元素，赋值给high
* 当low和high相遇时，此下标指向的元素就是 pivot
* 一次Patition结束，此时low/high的左边是比pivot小的元素，low/high右边是比pivot大的元素
* 返回pivot的下标（low/high），作为下一次Patition的区间

public static int Partition(int[] array, int low, int high){
int pivot = array[low];
while(low < high){
//注意这两个循环的顺序，如果是先low后high，第一个坑没法填，最后一个数白白丧失
//注意可以是 >=和<=，或 >=和<，或 >和<=
//不能是< 和 > , 相等的也交换，死循环
while(low < high && array[high] >= pivot){
high–;
}
array[low] = array[high];
while(low < high && array[low] <= pivot){
low++;
}
array[high] = array[low];
}
array[low] = pivot;
return low;
}


#### Hoare法实现Partition


**中心思想：左右交换**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/b93a28bc88f14a8eaa4e44bb421438ab.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)


* 找一个元素作为基准（pivot）（此处是第一个元素作基准）
* high从右边开始遍历，left从左边开始遍历
* high找到比 pivot 小的元素，low找到比 pivot 大的元素，交换元素
* high与left相遇时，此下标指向的元素 小于pivot ，与 区间起点 的元素交换
* 返回pivot的下标（low/high），作为下一次Patition的区间

public static void Swap(int[] array, int i, int j){
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}
public static int Hoare(int[] array, int low, int high){
    int start = low;
    int pivot = array[low];
    while(low < high){
//注意顺序，先后再前，让high去找low，两者相遇的地方是比temp小的数
//同样可以是>=和<= 或 >和<= 或 >=和<
//如果是>,< 会死循环的
        while(low < high && array[high] >= pivot){
            high--;
        }
        while(low < high && array[low] <= pivot){
            low++;
        }
        Swap(array,low,high);
    }
    Swap(array,low,start);
    return low;
}


### 递归分治


* 通过递归的方式对左右两个小区间再进行快速排序，直到区间长度为1时，递归结束

public static void quickSort(int[] array, int start, int end){
    if(start >= end){
        return;
    }
    int pivot = Partition(array,start,end);

    quickSort(array,start,pivot-1);
    quickSort(array,pivot+1,end);
}
//这一步没JB用，就保持下统一性而已
public static void quickSort(int[] array){
    quickSort(array,0,array.length-1);
}


#### 时间空间复杂度


**稳定性：不稳定**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/ad12e04eb86842bc813811aee702f6a9.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)  
 **最坏情况时，可能会出现栈溢出的情况**  
 所以可以通过基准值的选择进行优化


### 优化


1. **基准值的选择**


* 选择边上（low或者high）
* 随机选择，可以将随机下标的值与low下标的值互换
* 三数取中，要求 array[mid] <= array[low] <= array[high]


2. 待排序区间小于一个阈值时，使用直接插入排序


#### 三数取中


**还是array[low] 作基准(pivot)  
 三数取中  
 让array[mid] <= array[low] <= array[high]**  
 可以确定其中最大/最小数的位置，在比较其余两个数

//元素交换
public static void Swap(int[] array, int i, int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
//array[mid] <= array[low] <= array[high]
//很多种方法，不一一列举了
public static void ThreeMiddle(int[] array,int low, int high){
int mid = (low+high)/2;
if(array[low] < array[mid]){
Swap(array,low,mid);
}
if(array[high] < array[low]){
Swap(array,low,high);
}
if(array[low] < array[mid]){
Swap(array,low,mid);
}
}


### 非递归分治


**中心思想：区间边界放栈中，怕甚(Partition)一次取两个**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/a14964cd57cc4a738536ee65220a9634.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)


* 调用Partition后，找到pivot
* 把当前pivot的**左区间和右区间的边界下标**放到栈中，当这个区间至少有两个元素的时候，才入栈；若只有一个元素，说明有序了，不再入栈
* 判断栈是否为空，如果不为空的话，弹出栈顶的**两个元素**，放的顺序决定第一个元素给low还是给high
* 再进行Partition

public static void quickSort2(int[] array){
    if(array.length == 0){
        return;
    }
    Stack<Integer> stack = new Stack<>();
    stack.push(0);
    stack.push(array.length-1);
    while(!stack.isEmpty()){
        int high = stack.pop();
        int low = stack.pop();
        int pivot = Partition(array,low,high);
        if(pivot > low+1) {
            stack.push(low);
            stack.push(pivot - 1);
        }
        if(pivot < high-1) {
            stack.push(pivot + 1);
            stack.push(high);
        }
    }
}


## 七、归并排序


**中心思想:** **合并两个有序“数组”**  
 先将已有的序列分解成较短的子序列，使每个子序列有序，再将已经有序的子序列合并，得到完全有序的序列，即**分解与合并**  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/088f5386a8dc4309a825e1b462a7b9ef.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)


### 归并排序（递归）


![在这里插入图片描述](https://img-blog.csdnimg.cn/1d6ee65977c14d3387c11b3c73acc21a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)


* 将数组通过递归分解，直到low=high时（即只有一个元素的时候），递归结束
* 利用递归改变left和right，将新的 [ left，mid ] 看作一个数组，将 [ mid+1，right ] 看作一个数组，**将两个有序数组 合并成 一个有序数组**

public static void merge(int[] array, int low, int mid, int high){
int[] temp = new int[high-low+1];
int k = 0;
int s1 = low;
int e1 = mid;
int s2 = mid+1;
int e2 = high;
while(s1 <= e1 && s2 <= e2){
while(s1 <= e1 && array[s1] <= array[s2]){
temp[k++] = array[s1++];
}
while(s2 <= e2 && array[s2] <= array[s1]){
temp[k++] = array[s2++];
}
}
while(s1 <= e1){
temp[k++] = array[s1++];
}
while(s2 <= e2){
temp[k++] = array[s2++];
}
for (int i = 0; i < temp.length; i++) {
array[i+low] = temp[i];
}
}
public static void mergeSort(int[] array, int low, int high){
if(low == high){
return;
}
int mid = (low+high)/2;
mergeSort(array,low,mid);
mergeSort(array,mid+1,high);
merge(array, low, mid, high);
}

public static void mergeSort(int[] array){
    mergeSort(array,0,array.length-1);
}


### 非递归的归并排序


* 通过gap控制需要合并的两个序列的长度，1–>2–>4–>8
* 在gap的一次循环中，s1、e1、s2、e2遍历所有的序列，合并两个有序的序列
* 可能序列正好匹配 可能只剩下一段序列（没有与之合并的第二段序列）；如果剩下无法合并的序列，不做改变

public static void merge(int[] array, int gap){
int[] temp = new int[array.length];
int k = 0;
int s1 = 0;
int e1 = s1+gap-1;
int s2 = e1+1;
int e2 = s2+gap-1 > array.length-1 ? array.length-1 : s2+gap-1;
//有两段
while(s2 < array.length) {
while (s1 <= e1 && s2 <= e2) {
while (s1 <= e1 && array[s1] <= array[s2]) {
temp[k++] = array[s1++];
}
while (s2 <= e2 && array[s2] <= array[s1]) {
temp[k++] = array[s2++];
}
}
while(s1 <= e1) {
temp[k++] = array[s1++];
}
while(s2 <= e2){
temp[k++] = array[s2++];
}
s1 = e2+1;
e1 = s1+gap-1;
s2 = e1+1;
e2 = s2+gap-1 > array.length-1 ? array.length-1 : s2+gap-1;
}
//只有一段了
while(s1 < array.length && s1 <= e1){
temp[k++] = array[s1++];
}

    for (int i = 0; i < temp.length; i++) {
        array[i] = temp[i];
    }
}
public static void mergeSort2(int[] array){
    for (int gap = 1; gap < array.length; gap\*=2) {
        merge(array,gap);
    }
}


## 时间复杂度与空间复杂度


![在这里插入图片描述](https://img-blog.csdnimg.cn/e39bdadb89984e259ab3151e78fc5a47.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aiB5bCR5oC75Yag5Yab,size_20,color_FFFFFF,t_70,g_se,x_16)


### 计算运行时间的小妙招

    long begin = System.currentTimeMillis();
    insertSort(array);
    long end = System.currentTimeMillis();
    System.out.println(end - begin);



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）**
![img](https://img-blog.csdnimg.cn/img_convert/cd0538651dfa0a7eceaeb469611eb863.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

stem.currentTimeMillis();
        insertSort(array);
        long end = System.currentTimeMillis();
        System.out.println(end - begin);

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）
[外链图片转存中…(img-rp6voyC6-1713377969634)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！