排序（冒泡、选择、插入、希尔、快排、堆排、归并）

冒泡排序

  冒泡排序时通过无序区中相邻记录的关键字间的比较和位置的交换，使关键字最小的元素如气泡似的逐步上浮直水面。有序区逐渐扩大，无序区逐渐缩小。
  冒泡排序算法的原理如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

动画演示

冒泡排序是一种非常容易理解的排序
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

普通冒泡

void bubble0(vector<int>& arr)
{
   
    int size = arr.size();
    for(int i = 0; i < size; ++i) 
    {
     
        for(int j = 0; j < size-i-1; ++j)
        {
   
            if(arr[j] > arr[j+1])
            {
   
                swap(arr[j+1], arr[j]);
            }
        }
    }
}

优化一
  第一种优化就是在交换的地方加一个标记，如果某一趟排序没有交换元素，说明这组数据已经有序，不用再继续下去。这样对部分连续有序而整体无序的数据大大提升了效率。

void bubble1(vector<int>& arr)
{
   
    int size = arr.size();
    for(int i = 0; i < size; ++i)
    {
     
        bool flag = true;
        for(int j = 0; j < size-i-1; ++j)
        {
   
            if(arr[j] > arr[j+1])
            {
   
                flag = false;
                swap(arr[j+1], arr[j]);
            }
        }
        if(flag)
            return;
    }
}

优化二
  对于优化一来说，仅仅对部分连续有序而整体无序的数据效率高一些，如果这组数据时前面无序，但是后面的部分有序，效率就不是那么高了。因此可以在优化一的基础上记下最后一次交换的位置，这个位置后没有交换，必然是有序的，然后下一次排序从第一个比较到上次记录的位置结束即可。

void bubble2(vector<int>& arr)
{
   
    int size = arr.size() -1;
    int pos = size;
    for(int i = 0; i < size; ++i)
    {
   
        bool flag = true;
        int k = 0;
        for(int j = 0; j < pos; ++j)
        {
   
            if(arr[j+1] < arr[j])
            {
   
                flag = false;
                swap(arr[j+1], arr[j]);
                k = j;
            }
        }
        if(flag)
            return;
        pos = k;
    }
}

优化三
  冒泡算法经过优化二后效率有很大的提升，但是效率还可以继续优化，就是在一趟排序中确定两个最值，也就是一个正向查找最大值，另一个反向查找最小值

void bubble3(vector<int>& arr)
{
   

    int size = arr.size() -1;
    int pos = size;
    int pos1 = 0; 
    for(int i = 0; i < size; ++i)
    {
   
        bool flag = true;
        int k = 0; 
        //正向冒最大值
        for(int j = 0; j < pos; ++j)
        {
   

            if(arr[j+1] < arr[j])
            {
   

                flag = false;
                swap(arr[j+1], arr[j]);
                k = j;
            }
        }
        if(flag)
            return;
        pos = k;

        //反向冒最小值
        int n = pos1;
        for(int j = k; j > pos1; --j)
        {
   
            if(arr[j-1] > arr[j])
            {
   
                swap