C++ 实现 冒泡、插入、选择、归并、快速、希尔排序

#include <iostream>
#include <vector>
#include <set>
#include <algorithm>

using namespace std;



 class Solution
 {
 public:
    /***************************************************
    *  函数功能：冒泡排序 从小到大
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-06-30-10.58
    ***************************************************/
    void maopao(vector<int>& number)
    {
        bool flag=true;
        for(int i=0;i<number.size() && flag;i++)
        {
            flag=false;
            for(int j=number.size()-1;j>i;j--)
            {
                if(number[j]<number[j-1])
                {
                    flag=true;
                    SWAP(number,j,j-1);
                }
            }

        }
    }
    /***************************************************
    *  函数功能：选择排序
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-06-30-11.13
    ***************************************************/
    void choice_sort(vector<int>& number)
    {
        for(int i=0;i<number.size();i++)
        {
            int index=i;
            for(int j=i+1;j<number.size();j++)
            {
                if(number[index]>number[j])
                {
                    index=j;
                }
            }
            if(index!=i)
            {
                SWAP(number,i,index);
            }
        }
    }
    /***************************************************
    *  函数功能：插入排序
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(n^2)，空间复杂度：O(1)
    *  题目来源  ：
    *  日期：2018-06-30-14.18
    ***************************************************/
    void insert_sort(vector<int>& number)
    {
        for(int i=0;i<number.size();i++)
        {
            int temp=number[i];
            int j=i-1;
            while(j>=0 && temp<number[j])
            {
                number[j+1]=number[j];
                j--;
            }
            number[j+1]=temp;
        }
    }
    /***************************************************
    *  函数功能：快速排序
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(nlogn)，空间复杂度：O(n)
    *  题目来源  ：
    *  日期：2018-06-30-15.34
    ***************************************************/
    void quick_sort(vector<int>& number)
    {
       if(number.size()<2) return ;
       partition_sorts(number,0,number.size()-1);
    }
    /***************************************************
    *  函数功能：归并排序
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(nlogn)，空间复杂度：O(n)
    *  题目来源  ：
    *  日期：2018-06-30-16.26
    ***************************************************/
    void guibing_sort(vector<int>& number)
    {
        if(number.size()<2) return ;
        GB_sort(number,0,number.size()-1);
    }
    /***************************************************
    *  函数功能：希尔排序，对插入排序的改进
    *  参数说明
    *       输入参数：
    *       输出参数：
    *  复杂性分析：时间复杂度：O(nlogn)，空间复杂度：O(n)
    *  题目来源  ：
    *  日期：2018-06-30-16.53
    ***************************************************/
    void shell_sort(vector<int>& number)
    {
        if(number.size()<2)  return ;
        int step=number.size();
        do
        {
            step=step/3+1;
            for(int i=step;i<number.size();i+=step)
            {
                int temp=number[i];
                int index=i-step;
                while(index>=0 && number[index]>temp)
                {
                    number[index+step]=number[index];
                    index-=step;
                }
                number[index+step]=temp;
            }
        }while(step>1);
    }
 private:
   void GB_sort(vector<int>& number,int low,int high)
   {
       if(low<high)
       {
           int mid=low+(high-low)/2;
           GB_sort(number,low,mid);
           GB_sort(number,mid+1,high);
           MergeSort(number,low,mid,high);
       }
   }
   void MergeSort(vector<int>& number,int low,int mid,int high)
   {
       int i=low;
       int j=mid+1;
       vector<int> temp;
       while(i<=mid && j<=high)
       {
           if(number[i]>=number[j])
           {
               temp.push_back(number[j++]);

           }else
           {
               temp.push_back(number[i++]);
           }
       }
       for(;i<=mid;i++)
       {
           temp.push_back(number[i]);
       }
       for(;j<=high;j++)
       {
           temp.push_back(number[j]);
       }
       for(int i=0;i<temp.size();i++)
       {
           number[low+i]=temp[i];

       }
   }

   void partition_sorts(vector<int>& number,int start,int ends)
   {
        if(start<ends)
        {
            int q=Partition(number,start,ends);
            partition_sorts(number,start,q-1);
            partition_sorts(number,q+1,ends);
        }
   }
   int  Partition(vector<int>& number,int low,int high)
   {
       int temp=number[low];
       while(low<high)
       {
           while(low<high && temp<=number[high])
           {
               high--;
           }
           SWAP(number,low,high);
           while(low<high && temp>=number[low])
           {
               low++;
           }
           SWAP(number,low,high);
       }
       return low;
   }

   void SWAP(vector<int>& number,int x,int y)
   {
       int temp=number[x];
       number[x]=number[y];
       number[y]=temp;
   }
 };

 int main()
 {
    Solution ss;
    vector<int> number;
    int n=12;
    for(int i=0;i<n;i++)
    {
        number.push_back(rand()%100);
    }
    for(int i=0;i<n;i++)
    {
        cout<<number[i]<<" ";
    }
    cout<<endl;

    ss.shell_sort(number);

    for(int i=0;i<number.size();i++)
    {
        cout<<number[i]<<" ";
    }
    return 0;
 }