2024年Python最全【算法】常见排序算法总结_排序法在彩虹中的运用，面试阿里p7有多难

于 2024-05-03 21:19:13 发布
阅读量885 收藏 30
点赞数 22
分类专栏： 程序员 文章标签： 算法 python 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54853787/article/details/138424934
版权

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

在这里插入图片描述

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

在这里插入图片描述

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

在这里插入图片描述

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

需要这份系统化学习资料的朋友，可以戳这里获取

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

实现代码：

 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) {
        //处理gap
        int gap = array.length;
        while (gap > 1) {
            gap  = gap / 3 + 1;//+1 保证最后一个序列是 1 除几都行
            // gap /= 2;
            shell(array,gap);
        }
    }

排序性能分析

由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，可理解为元素可能会跳跃式移动，所以最后其稳定性就会被打乱，因此shell排序是不稳定的。
时间复杂度：不同的增量序列会产生不同的时间复杂度，比如有人提出当增量序列为在这里插入图片描述
是，其时间复杂度为在这里插入图片描述
其中t为排序趟数，且：在这里插入图片描述
总结：

  1. 稳定性：不稳定
  1. 时间复杂度：不确定，但可以记为N(1.3) 到N(1.5) 之间

选择排序

原理

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

实现

在这里插入图片描述
实现代码：

 public static void selectSort(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[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        }
    }

排序性能分析

选择排序较为简单，其最好的情况和最坏的情况下程序执行的次数是一样的，因此时间复杂度是一个定值
总结

  1. 时间复杂度：O（N2 )
  1. 空间复杂度：O（1）

堆排序

原理

  1. 堆排序是利用堆这种数据结构设计出的一种排序算法，其是选择排序的一种，它利用大顶堆(小顶堆)堆顶元素是最大值(最小值)这一特性，使得每次从无序中选择最大值(最小值)变得简单。
  2. 排升序要建大堆；排降序要建小堆。

具体步骤如下
step1：先将带排序的数组构造成一个大根堆，假设有如下数组：int[] array2={2,3,4,1,6,5};

在这里插入图片描述
构造成大根堆如下：
在这里插入图片描述

step2：将堆顶元素与堆尾元素交换：在这里插入图片描述
step3：将除6以外其他的所有元素继续构造大根堆：在这里插入图片描述
以此类推，然后再将堆顶元素与堆中倒数第二个元素交换，换完之后除了倒数第一个和倒数第二个元素以外，其他元素继续构造成大堆，最终会得到有序的数组
在这里插入图片描述
同理，如果要从大到小排，则构建小堆即可！

实现

public static void siftDown(int[] array,int root,int len) {
        int parent = root;
        int child = 2\*parent+1;
        while (child < len) {
            //找到左右孩子的最大值
            //1、前提是你得有右孩子
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            //child的下标就是左右孩子的最大值下标
            if(array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                parent = child;
                child = 2\*parent+1;
            }else {
                break;
            }
        }
    }

    public static void createHeap(int[] array) {
        //从小到大排序 -》 大根堆
        for (int i = (array.length-1 - 1) / 2;  i >= 0 ; i--) {
            siftDown(array,i,array.length);
        }
    }
    public static void heapSort(int[] array) {
        createHeap(array);//O(n)
        int end = array.length-1;
        while (end > 0) {//O(N\*logN)
            int tmp = array[end];
            array[end] = array[0];
            array[0] = tmp;
            siftDown(array,0,end);
            end--;
        }
    }

排序性能分析

  1. 时间复杂度：O(N* log(N))（最好和最坏的都是这个）
  1. 空间复杂度：O（1）（在整个调整的过程中并没有重新定义数组）
  1. 稳定性：不稳定

这个堆排序我上一篇博客中有详细地讲过哦，相信大家看完后一定会有收获的有关堆的相关知识点
在这里插入图片描述

冒泡排序

原理

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。一直重复进行上述步骤，直到没有元素再需要交换，也就是说该数列已经排序完成。

实现

在这里插入图片描述

public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
        }
    }

排序性能分析

  1. 时间复杂度：最好/最坏：O（N2 ），若优化，则最好的情况下时间复杂度为O（n）
  1. 空间复杂度：O（1）
  1. 稳定性：稳定

优化方法

 public static void bubbleSort(int[] array) {
        // boolean flg = false;
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg == false) {
                break;
            }
        }
    }

设置一个flg，若当前排序时已经有序，可以提前结束本次循环

快速排序

原理

  1. 快速排序是对冒泡排序的一种改进。
  2. 排序前首先选择一个基准值（pivot）将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再对左右两个区间选取基准值，重复此步骤，采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度为1，代表已经有序，或者小区间的长度为0，代表没有数据，排序完成！整个排序过程可以递归进行，也可以非递归进行（如使用栈）

基准的选取（递归实现快速排序）

挖坑法

定义两个变量，假如数组的首元素位置下标是low，数组的尾元素位置下标是high，挖坑法为固定位置选取基准法，比如让low下标的元素作为基准，让其存到临时变量tmp当中，然后将high从后往前遍历，找比tmp的值小的数字，若找到，则将这个值存到low下标对应的位置中。接着让low从左到右遍历去找比tmp的值大的元素，若找到，则将其值存到high下标对应的位置中，以此循环。直到low和high相遇，那么就把tmp的值放到相遇位置作为基准即可。这样即可实现把要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小了
在这里插入图片描述
实现代码：

public static int partition(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= tmp) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = tmp;
        return low;
    }

有了基准后，就可以进行快速排序的下一步了，然后再对左右两个小区间选取基准值进行排序，下面我们将使用递归的方法：

import java.util.Arrays;

public class TestDemo {
    public static int partition(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= tmp) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = tmp;
        return low;
    }
    public static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }
    public static void quickSort1(int[] array) {
        quick(array,0,array.length-1);
    }

    public static void main(String[] args) {
        int[] array={12,5,37,41,55,28,6,1,69,17};
        quickSort1(array);
        System.out.println(Arrays.toString(array));
    }
}

打印的结果为：在这里插入图片描述
排序完成！
性能分析

  1. 时间复杂度：
    最好情况：O（N*logN）（每一次排序时分割区间都是均匀的）
    最坏情况：O（N2）（对已经有序的一对数据排序）
  1. 空间复杂度：
    最好：O（logN）
    最坏：O（N）
  1. 稳定性：不稳定
三数取中

对于上述用挖坑法递归进行快速排序时，因为空间复杂度为O（n），那么当数据足够多时且越趋于有序而导致排序分割的区间不均匀时，那可能会栈溢出（因为递归是在栈上开辟内存的），因此，我们可以用三数取中来实现让排序的区间更趋于均匀，从而提升算法的效率。
具体思路：
让low下标等于数组首元素位置，让high等于数组最后一个元素的位置，定义一个mid使其等于数组的中间位置，然后让low下标的值等于这三个下标对应的值第二大的，即中间大小的值
实现代码：

mport java.util.Arrays;

public class TestDemo {
    public static int partition(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= tmp) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = tmp;
        return low;
    }
    public static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
    public static void selectPivotMedianOfThree(int[] array,int start,int end,int mid) {
        //array[mid] <= array[start] <= array[end]
        if(array[mid] > array[start]) {
            swap(array,start,mid);
        }// array[mid] <= array[start]
        if(array[start] > array[end]) {
            swap(array,start,end);
        }// array[start] <= array[end]
        if(array[mid] > array[end]) {
            swap(array,start,end);
        }// array[mid] <= array[end]
    }
    public static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        int mid = (start+end)/2;
        selectPivotMedianOfThree(array,start,end,mid);
        int pivot = partition(array,start,end);
        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }
    public static void quickSort1(int[] array) {
        quick(array,0,array.length-1);
    }

    public static void main(String[] args) {
        int[] array={12,5,37,41,55,28,6,1,69,17};
        quickSort1(array);
        System.out.println(Arrays.toString(array));
    }
}
优化

利用递归法求基准进行快速排序时，当分割的区间越来越小时，其区间内的数据越趋于有序，因此我们可以设定一个区间范围，然后在这个区间范围进行直接插入排序，排好序之后就不再递归了，这样可以大大提高算法的效率
直接插入排序部分代码：

 //判断两个下标之间的数据个数
        if(end-start+1 <= 100) {
            insertSort2(array,start,end);//这里要调用之前写好的直接插入排序的代码
            return;//这里一定要return

利用栈（非递归实现快速排序）

除了上面我们可以利用递归实现快速排序，我们也可以利用非递归实现快速排序，其步骤如下：

  1. 先选取基准（pivot），以挖坑法为例。
  1. 找到基准后，把基准左区间两端的下标和右区间两端的下标放入栈里
  1. 判断栈是否为空，若不为空，则弹出栈顶两个元素。
  1. 继续进行步骤一

注意：当一个区间至少有两个元素的时候才可以入栈。

实现动图（以找到基准为例）

在这里插入图片描述
在这里插入图片描述

实现代码：

  public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int start = 0;
        int end = array.length-1;
        int pivot = partition(array,start,end);
        //左边有2个元素及以上
        if(pivot > start+1) {
            stack.push(0);
            stack.push(pivot-1);
        }
        if(pivot < end-1) {
            stack.push(pivot+1);
            stack.push(end);
        }
        while (!stack.empty()) {
            end = stack.pop();
            start = stack.pop();
            pivot = partition(array,start,end);
            //左边有2个元素及以上
            if(pivot > start+1) {
                stack.push(0);
                stack.push(pivot-1);
            }
            if(pivot < end-1) {
                stack.push(pivot+1);
                stack.push(end);
            }
        }
    }

归并排序

原理

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并
在这里插入图片描述
在这里插入图片描述

递归实现

实现代码
import java.util.Arrays;

public class Test {
    public static void merge(int[] array,int low,int mid,int high) {
        int s1 = low;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = high;


### 最后

> **🍅 硬核资料**：关注即可领取PPT模板、简历模板、行业经典书籍PDF。  
> **🍅 技术互助**：技术群大佬指点迷津，你的问题可能不是问题，求资源在群里喊一声。  
> **🍅 面试题库**：由技术群里的小伙伴们共同投稿，热乎的大厂面试真题，持续更新中。  
> **🍅 知识体系**：含编程语言、算法、大数据生态圈组件（Mysql、Hive、Spark、Flink）、数据仓库、Python、前端等等。




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

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
中新经纬在线
关注
  • 22
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值