排序个人总结

大翔plus2024-09-26 10:01

插入排序

思路；定义 i 和 **j，**默认 i 前面的数都是有序的，j 定义为 i 的前一个数，把 i 的值给tmp，tmp与j对应的值进行比较，如果arr[j] > tmp,将arr[j] (大的数前移一位)，如下图

代码：

java 复制代码 
    //插入排序
    //每次循环i前面的值都是有序的
    public void insertSort(int[] arr){

        for (int i = 1; i < arr.length; i++) {
            int j = i-1;        //j定义为i的前一个数
            int tmp = arr[i];   //将arr[i]设置为临时变量，插入i前面有序的数组中
            for(;j>=0;j--){

                if(arr[j]>tmp){
                    arr[j+1]=arr[j];        //前移
                }else {
                    //代表前面已经有序了
                    //arr[j+1]=tmp;       //将tmp放回到原来的位置
                    break;
                }
            }
            arr[j+1]=tmp;       //跳出循环的时候，j已经小于0了,

        }

    }

特点：时间复杂度

最好情况下：数据都是有序的情况下：O(N)

最坏情况下：数据完全逆序的O(n^2)

空间复杂度 O(1)

稳定性：稳定的

希尔排序

思路：数组分组进行排序，如下

10个数，分5组，组内进行排序，组内使用插入排序，

再分两组，组内进行排序，

最后分一组，排序完成

代码如下

java 复制代码 
//希尔排序
    public void shellSort(int[] arr){
        int gap = arr.length;   //gap分的组，
        while (gap>1){
            gap = gap/3 +1 ;
            shell( arr , gap);      //将分好的组进行插入排序
        }

    }
    private void shell(int[] arr, int gap){     //这里和插入排序思路一样，只是插入排序中，            
                                                //我们按照1来进行计算，这里按照gap来进行计算
                                                //建议：先把插入排序写完，再写希尔排序
        for(int i = gap;i<arr.length;i++){
            int j = i-gap;
            int tmp = arr[i];

            for(;j>=0;j-=gap){
                if(arr[j]>tmp){
                    arr[j+gap]=arr[j];              //大的数后移
                }else {
                    break;
                }
            }
            arr[j+gap]=tmp;
        }
    }

特点：不稳定排序，时间复杂度不好计算

选择排序

思路；定义一个i下标，和 j= i + 1，将i下标定义为minIndex，j向后遍历，寻找i后面比minIndex还要小的值，找到了就重新定义minIndex，循环结束后和i的位置进行交换

代码如下：

java 复制代码 
    //选择排序
    public void selectSort(int[] arr){
        for(int i = 0;i<arr.length;i++){
            int j = i+1;                //j在i的前一个数，j向后寻找比i下标值小的数，找到了就和    
                                        //i下标的值交换，找不到就向后移动
            int minIndex = i;
            for(;j<arr.length;j++){
                if(arr[j]<arr[minIndex]){
                    minIndex=j;         //跟新最小值下标
                }
            }
            //循环结束后，找到了i前面的最小值小标
            //将i的位置和最小值下标交换
            Swap(arr,i,minIndex);

        }

    }
    private static void Swap(int[] arr,int a,int b){
        int tmp = arr[a];
        arr[a]=arr[b];
        arr[b]=tmp;

    }

特点：时间复杂度O(N^2)

空间复杂度O(1)

稳定性：不稳定

堆排序

堆排序需要将数组变成大根堆。

因为是大根堆，所以头节点是最大的，将头节点和尾节点进行交换，让后向下调整，每次调整后都将最大的节点放到尾部，调整完后就是从小到大的排序

代码如下

java 复制代码 
//堆排序
    //堆排序首先需要创建大根堆，
    public void headSort(int[] arr){
        //先将数组变成大根堆
        createBigHead(arr);
        int end = arr.length -1;
        while (end > 0){
            Swap(arr,0,end);            //交换头和最后一位节点进行向下调整
            shiftDown(arr,0,end);
            end--;
        }
    }
//创建大根堆/采用向下调整的方法
    public void createBigHead(int [] arr){
        int end = arr.length;
       int parent = (arr.length-1-1)/2;         //最后一颗子树的父亲节点，开始向下调整
        for(;parent>=0;parent--){
            shiftDown(arr,parent,end);
        }
    }
    private static void shiftDown(int[] arr,int parent,int end){
        int child = 2*parent +1 ;               //左孩子节点
        while (child<end){
            //找出孩子节点中最大的一个，和父亲节点进行交换
            if(child+1<end&&arr[child]<arr[child+1]){
                child=child+1;
            }
            if(arr[child]>arr[parent]){
                Swap(arr,child,parent);
                //交换完成后父亲和孩子节点向下调整
                parent=child;
                child = 2*parent+1;
            }else {
                break;
            }
        }

    }

快速排序

思路：

代码如下

java 复制代码 
public void quickSort(int [] arr){
        int start = 0;              //设置开始和结束
        int end = arr.length-1;     
        quick(arr,start,end);       //调用方法
    }
    public void quick(int[] arr,int start,int end){

        if(start>=end){         //当开始大于结束时，递归结束
            return;
        }
        int pivot = partition(arr,start,end);       
        quick(arr,start,pivot-1);
        quick(arr,pivot+1,end);

    }

    public int partition(int[] arr, int left ,int right){
        int tmp = arr[left];            //设置第一个值为基准
        int i = left;                   //保留第一个值的位置

        while (left<right){

             while (left<right&&arr[right]>=tmp){
                right--;                            //从右边开始找，找到比tmp小的值让后停下来
            }            


             while (left<right&&arr[left]<=tmp){     //第一个判定条件是防止整个数组的值都比tmp小，从而导致数组越界
                left++;                             //从左边开始找，找到比tmp大的值让后停下来
            }
           
            Swap(arr,left,right);                   //交换，两个值，有可能left和right相等，相等就交换自己

        }
        Swap(arr,i,left);                       //把相遇的点和第一位交换
        return left;                            //返回left和right相遇的点

    }

上述是快速排序的一种方法，下面是第二种方法，挖坑法

java 复制代码 
public int partition2(int [] arr,int left,int right){
        int tmp = arr[left];
        int i = left;
        while (left<right){

            while (left<right&&arr[right]>=tmp){
                right--;
            }
            arr[left]=arr[right];           //右边找到比tmp小的，直接交换


            while (left<right&&arr[left]<=tmp){
                left++;
            }
            arr[right]=arr[left];       //左边找到比tmp大的，直接交换




        }
        arr[left]=tmp;          //将取出的tmp放回到空格处
        return left;
    }

这里有个疑问，为啥

复制代码 
while (left<right&&arr[left]<=tmp){
    left++;
}
arr[right]=arr[left];       //左边找到比tmp大的，直接交换
复制代码 
while (left<right&&arr[right]>=tmp){
    right--;
}
arr[left]=arr[right];           //右边找到比tmp小的，直接交换

这两个循环换一下执行顺序就出错了，不理解我就死记了

特点：时间复杂度n*logn，是不稳定的排序

归并排序

思路：将数组分裂，分裂结束后再进行组内合并

合并的时候需要创建一个新的数组用来存放排序好的数组

java 复制代码 
//归并排序
    public void mergeSort(int[] arr){
        mergeFunc(arr,0,arr.length-1);
    }

    public void mergeFunc(int[] arr,int left,int right){
        if(left>=right){
            return;
        }
        //进行分裂
        int mid = (left+right)/2;
        mergeFunc(arr,left,mid);        //分裂左边
        mergeFunc(arr,mid+1,right);     //分裂右边
        //分裂完后进行合并
        merge( arr, left,mid,right);

    }
    public void merge(int[] arr,int left,int mid,int right){
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        int[] tmp = new int[(right-left)+1];
        int k = 0;
        while (s1<=e1&&s2<=e2){  //代表分裂的这段有数据
            //s1和s2进行比较
           if(arr[s1]<=arr[s2]){
               tmp[k++]=arr[s1++];      //谁小放谁进去
           }else {
               tmp[k++]=arr[s2++];
           }
        }
        while (s1<=e1){              //如果有一个没有数据了，直接把剩下的全放进去
            tmp[k++]=arr[s1++];
        }
        while (s2<=e2){
            tmp[k++]=arr[s2++];
        }
        
        //再把数据拷贝回原来的数组中
        for (int i = 0; i < k; i++) {
            arr[i+left]=tmp[i];        //拷贝回原来的数组
        }

    }
相关推荐
海海不掉头发23 分钟前
【已解决】如何使用JAVA 语言实现二分查找-二分搜索折半查找【算法】手把手学会二分查找【数据结构与算法】
java·开发语言·算法
我要学编程(ಥ_ಥ)1 小时前
滑动窗口算法专题（2）
数据结构·算法·leetcode
_Power_Y1 小时前
浙大数据结构：05-树9 Huffman Codes
数据结构·c++·算法
爱吃土豆的程序员2 小时前
Lucene 倒排索引原理详解：深入探讨相关算法设计
java·算法·elasticsearch·全文检索·lucene
4v1d3 小时前
从决策树到GBDT、随机森林
算法·决策树·随机森林
顾城猿4 小时前
9.25-编程刷题
数据结构·算法·leetcode
王哈哈嘻嘻噜噜4 小时前
c语言中的杨氏矩阵的介绍以及元素查找的方法
c语言·算法·矩阵
所待.3834 小时前
剖解环形链表1
数据结构·链表
大柏怎么被偷了4 小时前
【C++算法】栈
开发语言·c++·算法
小柯J桑_4 小时前
史上最牛排序集合，带你认清所有排序算法！（必看系列）~
数据结构·算法·排序算法
热门推荐
01大数据分析案例-基于SVM支持向量机算法构建手机价格分类预测模型02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04[Qt]Qt框架解析：从入门到精通，探索平台开发的无限可能05yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CANoe Trace窗口过滤栏消失的几种解决方法（附上最终解决方案）08RAG 实践- Ollama+RagFlow 部署本地知识库09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10软件工程从理论到实践客观题汇总(头歌第一章至第八章)