LeetCode算法题回顾排序算法之内部排序算法

最新推荐文章于 2023-10-23 15:28:24 发布

Min_20

最新推荐文章于 2023-10-23 15:28:24 发布

阅读量1.6k

点赞数 2

分类专栏： Leetcode 代码实现与解析

本文链接：https://blog.csdn.net/jucilan3330/article/details/88428937

版权

本文深入探讨了内部排序算法，包括冒泡排序、快速排序、直接选择排序、堆排序、直接插入排序、希尔排序和归并排序的原理、步骤、代码实现及其性质总结。文章强调了排序算法的稳定性、时间复杂度和空间复杂度的重要性，并提供了每种排序算法的优缺点分析。

摘要由CSDN通过智能技术生成

1.基础知识部分

排序算法分类：平常所说的排序算法大部分是指内部排序算法，其实还有三种常见的外部排序算法（计数、基数、桶排序）

内部排序和外部排序

内排序是指所有的数据已经读入内存，在内存中进行排序的算法。排序过程中不需要对磁盘进行读写。同时，内排序也一般假定所有用到的辅助空间也可以直接存在于内存中。
外排序，即内存中无法保存全部数据，需要进行磁盘访问，每次读入部分数据到内存进行排序。

下面给出它们的具体分类：

内部排序算法：冒泡排序、快速排序、直接择排序、直接插入排序、希尔排序、归并排序、堆排序
- 其中冒泡排序和快速排序属于交换排序，直接插入排序和希尔排序属于插入排序
外部排序算法：计数排序、基数排序、桶排序等

概念讲解

稳定性：如果i=j，排序前i在j的前面，排序后i仍然在j的前面，即相等的两个数字的相对位置在排序前后不变，则该算法是稳定的，否则不稳定。

举例: 用某一算法对[1,3,2,4,2]进行排序后的结果为[1,2,2,3,4]，我们可以看到排序前粗体2在细体2之前，排序之后仍然是，则该算法为稳定的。
稳定性作用：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，前一个键排序的结果可以为后一个键排序所用。可能比较难理解，这里再举个例子方便理解，比如在基数排序中，先将低位排序，再逐次按高位排序，稳定的话就可以保证排序后低位元素的顺序在高位相同时是不会改变的。

时间复杂度：指执行算法所需要的工作量，即对待排序数据的总操作次数，我们用它来描述算法的运行时间。
空间复杂度：指执行算法所需的内存空间。

Note：

每个算法的稳定性并不是绝对的，比如冒泡算法若把判断条件由原来的if L(j) > L(j+1)改成if L(j) >= L(j+1)，那么冒泡算法的稳定性就由原来的稳定变为不稳定（后面会详细讲解，这里只是举个例子

4.2 具体步骤（需要记住k节点的父节点的位置是[k/2]）

1.冒泡排序

1.1 基本思想

冒泡排序可以算是最简单、最基础的排序算法了，它的基本思想是：重复的遍历待排序的一组数字（通常是列表形式），依次比较两个相邻的元素（数字），若它们的顺序错误则将它们调换一下位置，直至没有元素再需要交换为止。因为每遍历一次列表，最大（或最小）的元素会经过交换一点点”浮“到列表的一端（顶端），所以形象的称这个算法为冒泡算法

1.2 具体步骤

比较两个相邻元素，如果前一个比后一个大，则交换这两个相邻元素
从头至尾对每一对相邻元素进行步骤1的操作，完成1次对整个待排序数字列表的遍历后，最大的元素就放在了该列表的最后一个位置上了
对除最后一个元素的所有元素重复上述步骤，这第二次遍历后第二大的元素就也放在了正确的位置（整个列表的倒数第二位置上）
不断重复上述步骤，每次遍历都会将一个元素放在正确的位置上，从而下次遍历的元素也会随之减少一个，直至没有任何一对数字需要比较

1.3 代码实现 c++

/* @Description:<p>冒泡排序算法实现*/

public class BubbleSort {
public :
    void bubbleSort(vector<int>& arr) {
        if( arr.size() == 0 || arr.size() ==1 )
            return ;
        for(int i=0; i<arr.size()-1; i++) {
            for(int j=arr.size()-1; j>i; j--) {
                if(arr[j] < arr[j-1])
                    swap(arr,j-1,j);
            }
        }
    }
  
public: 
    void swap(vector<int>& arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

};

但是上面代码的时间复杂度=O（n^2）,那么冒泡算法的最好状况时间复杂度O(n)是从何而来的呢，看下面的改进的冒泡算法

1.4 改进的冒泡排序算法 c++

可以发现，如果一组数字一开始就完全有序的话，上述算法还是会一遍一遍的遍历，对于这种不必要进行改进一下。

在排序后期可能数组已经有序了而算法却还在一趟趟的比较数组元素大小，可以引入一个标记，如果在一趟排序中，数组元素没有发生过交换说明数组已经有序，跳出循环即可。优化后的代码如下

/* @Description:<p>冒泡排序算法实现</p>*/
public class BubbleSort {
 //************ 冒泡排序算法实现 */
 
     //改进版冒泡排序
public:
    void bubbleAdSort(vector<int>& arr) {
        if(arr.size() == 0 || arr.size() ==1 )
            return ;
        bool flag = true;
        for(int i=0; i<arr.size(); i++){
            flag = true;
            for(int j=arr.size()-1; j>i; j--) {
                if(arr[j] < arr[j-1]) {
                    flag =false;
                    swap(arr, j-1, j);
                }
            }
            if(flag) break;
        }
    }

public:
    void swap(vector<int>& arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        }
};

1.5 性质总结：

时间复杂度
- 平均情况：O(n^2)
- 最好情况：O(n)
- 最坏情况：O(n^2)
空间复杂度：O(1)
稳定性：稳定 (仅限于本博客代码，前面说过若把判断条件由原来的if L(j) > L(j+1)改成if L(j) >= L(j+1)，那么稳定性就由原来的稳定变为不稳定！

2. 快速排序(Quick Sort)

快速排序采用了一种叫分治的思想。(idea = 分治+二分+冒泡）

分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

2.1 基本思想　

快速排序基本思想是：通过选取一个基准base，用一趟排序将待排序列表分割成独立的两部分，左边部分的所有元素都比base小，右边部分的所有元素都比base大，然后将左右两部分分别继续重复进行此操作，递归实现，从而达到最终将整个列表排序的目的。

2.2 具体步骤

从待排序列表（数组）中选择一个元素作为基准（pivot），这里我们选择最后一个元素元素
遍历列表，将所有小于基准的元素放在其前面，这样就可以将待排序列表分成两部分了
递归地对每个部分进行1、2操作，这里递归结束的条件是序列的大小为1，此时递归结束，排序就已经完成了

2.3 代码实现 c++

/***@Description:<p>实现快速排序算法</p>*/


class QuickSort {
public:
   void quicksort(vector<int> &vec, int left, int right)

    {

        if (left>= right) return;

        int keyloc = partition (vec,left, right);

        quicksort( vec, left, keyloc-1);

        quicksort( vec, keyloc+1, right);

    }

    

public:
//核心idea在于我们要在两端开始各自存储比key大和比key小的数
//所以选择left/right进行key值赋值后，我们要从另一端开始进行大小判定，才可以保证这个数不论大于KEY或者小于KEY都是在两端位置
    int partition (vector<int> &vec, int left, int right ){
        int