排序算法总结C++

排序算法

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。

排序分为内部排序和外部排序。

若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。

反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
八大排序算法均属于内部排序。如果按照策略来分类，大致可分为：交换排序、插入排序、选择排序、归并排序和基数排序。

冒泡排序

冒泡排序重复的扫描整个数组，在扫描过程中比较两个元素，如果不满足排序要求就将二者进行交换。每一次扫描都会将当前最大（或最小值移动到最后）。
算法描述
步骤一： 比较相邻的元素。如果前一个比后一个大，就交换它们两个；
步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
步骤3: 针对所有的元素重复以上的步骤，除了最后一个；
步骤4: 重复步骤1~3，直到排序完成。
动画如下

代码如下：

class Solution
{
   
    public:
    //冒泡排序
    vector<int> bubbleSort(vector<int> nums)
    {
   
        if(nums.size()==0||nums.size()==1)
        {
   
            return nums;
        }
        for (int i = 0; i < nums.size();i++)
        {
   
            //通过mark避免已经排序成功后的继续循环
            // 如nums[5,1,2,3,4],第一轮交换已经完成排序，后续就无需在继续扫描数组
            bool mark = true;
            // nums.size()-i-1,后面已经排好序的就不在扫描了
            for (int j = 0; j < nums.size()-i-1;j++)
            {
   
                if(nums[j+1]<nums[j])
                {
   
                    // swap(nums[j], nums[j + 1]);
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                    mark = false;
                }
            }
            if(mark)
            {
   
                return nums;
            }
        }
    }
};

快速排序

快速排序通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
算法步骤
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；
步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面
步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
图示如下

代码如下

class Solution
{
   
public:
    void quickSort(int left,int right,vector<int>&nums)
    {
   
        //取最左边元素为基准
        int pivot = nums[left];
        int i = left+1;
        int j = right;
        while(i<=j)
        {
   
            //从左寻找大于基准的数，返回索引i
            while(i<=j && nums[i]<=pivot)
            {
   
                i++;
            }
            //从右寻找小于基准的数，返回索引j
            while(i<=j && nums[j]>=pivot)
            {
   
                j--;
            }
            if(i>=j)
            {
   
                break;
            }
            //交换必须满足i<=j，考虑边界
            if(i<=j)
            {
   
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
            
        }
        nums[left] = nums[j];
        nums[j] = pivot;
        //递归处理左边和右边部分
        quickSort_sub(left, j - 1,nums);
        quickSort_sub(j + 1, right, nums);
    }
};

插入排序

插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
步骤1: 从第一个元素开始，该元素可以认为已经被排序；
步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；
步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
步骤5: 将新元素插入到该位置后；
步骤6: 重复步骤2~5。
动画如下

代码如下 插入法的关键在于找到插入位置，然后为插入数据腾地方

class Solution
{
   
public:
    vector<int> insertSort(vector<int> nums)
    {
   
        if (nums.size() == 0 || nums.size() == 1)
        {
   
            return nums;
        }
        for (int i = 1; i < nums.size();i++)
        {
   
            int temp = nums[i];
            int preIndex = i-1 ;
            //寻找插入位置，然后将数组值进行移动，腾出位置。
            while(preIndex>=0&&temp<nums[preIndex])
            {
   
                //再移动k的同时也要为待插入元素腾位置
                nums[preIndex+1] = nums[preIndex];
                preIndex--;
            }
            nums[preIndex+1] = temp;
        }
        return nums; 
    }
    //或者
    vector<int>insertSort(vector<int> nums)
    {
   
        if (nums