冒泡排序、插入排序、选择排序、希尔排序（C++实现）

冒泡排序：
冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。
最优时间复杂度:O(n)
最差时间复杂度:O(n^2)
平均时间复杂度:O(n^2)
稳定排序

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        int size=nums.size();
        int guodu;
        bool flag=false;
        for(int i=0;i<size;i++)
        {
            for(int j=0;j<size-i-1;j++)
            {
                if(nums[j]>nums[j+1])
                {
                    guodu=nums[j+1];
                    nums[j+1]=nums[j];
                    nums[j]=guodu;
                    flag=true;
                }
            }
            if(!flag)
            {
                break;
            }
        }
        return nums;    
    }
};

插入排序：
首先，我们将数组中的数据分为两个区间，已排序区间和未排序区间。初始已排序区间只有一个元素，就是数组的第一个元素。插入算法的核心思想是取未排序区间中的元素，在已排序区间中找到合适的插入位置将其插入，并保证已排序区间数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。
最优时间复杂度:O(n)
最差时间复杂度:O(n^2)
平均时间复杂度:O(n^2)
稳定排序

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        int size=nums.size();
        int guodu;
        int j;
        for(int i=1;i<size;i++)
        {
            guodu=nums[i];
            for(j=i-1;j>=0;j--)
            {
                if(nums[j]>guodu)
                {
                    nums[j+1]=nums[j];
                }
                else
                {
                    break;
                }
            }
            nums[j+1]=guodu;
        }
        return nums;
    }
};

希尔排序
希尔排序是插入排序的特例：希尔排序是将待排序的数组元素 按下标的一定增量分组 ，分成多个子序列，然后对各个子序列进行直接插入排序算法排序；然后依次缩减增量再进行排序，直到增量为1时，进行最后一次直接插入排序，排序结束。
第一个增量=数组的长度/2,
第二个增量= 第一个增量/2,
第三个增量=第二个增量/2,
以此类推，最后一个增量=1。
最优时间复杂度:O(n)
最差时间复杂度:O(n(log^2)n)
平均时间复杂度:O(n(log^2)n)
不稳定排序

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        int size=nums.size();
        int d=1;
        //为了产生较好的增量序列1、4、13、...、3n+1
        while(d<size/3)
        {
            d=3*d+1;
        }
        int guodu;
        int j;
        //代码就是插入排序外面多了一层for循环和增量序列准备工作
        for(;d>0;d=d/3)
        {
        	//写这段的时候当作是插入排序就好，只不过把循环的1改成d
        	//i=d意味着从序号d开始累加，进行i、i-d、i-2d...的排序
        	//i++意味着i递增到末尾，进行rear、rear-d、rear-2d、rear-3d...的排序
            for(int i=d;i<size;i++)
            {
                guodu=nums[i];
                //依次向前以d为单位进行插入排序
                for(j=i-d;j>=0;j=j-d)
                {
                    if(nums[j]>guodu)
                    {
                        nums[j+d]=nums[j];
                    }
                    else
                    {
                        break;
                    }
                }
                nums[j+d]=guodu;
            }
        }
        return nums;
    }
};

选择排序
选择排序算法的实现思路有点类似插入排序，也分已排序区间和未排序区间。但是选择排序每次会从未排序区间中找到最小的元素，将其放到已排序区间的末尾。
最优时间复杂度:O(n^2)
最差时间复杂度:O(n^2)
平均时间复杂度:O(n^2)
不稳定排序

class Solution 
{
public:
    vector<int> sortArray(vector<int>& nums) 
    {
        int size=nums.size();
        int guodu;
        int min_value;
        int min_index;
        bool flag=false;
        for(int i=0;i<size-1;i++)
        {
            min_value=nums[i];
            for(int j=i+1;j<size;j++)
            {
                if(nums[j]<min_value)
                {
                    min_index=j;
                    min_value=nums[j];
                    flag=true;
                }
            }
            if(flag)
            {
                guodu=nums[min_index];
                nums[min_index]=nums[i];
                nums[i]=guodu;
                 flag=false;
            }
        }
        return nums;
    }
};