C++ 7種排序方法代碼合集

 

 

class Solution {
public:

/********************************************************************
直接插入排序
數組前面維持一個有序區，每次從后面的無序區里選一個數插入到前面的有序區，直至全部已排序
*********************************************************************/
void insertsort(vector<int>& nums)
{
    for (int i = 1; i < nums.size(); i++)
    {
        //找到插入位置
        int insertpos = 0, insertval = nums[i];
        while (nums[insertpos] <= nums[i] && insertpos<i)insertpos++;
        //挪動位置來插入
        for (int j = i; j > insertpos; j--)
            nums[j] = nums[j - 1];
        nums[insertpos] = insertval;//插入
    }
}
/*********************************************************************
//希爾排序，直插排序的變形，執行以下循環:
//if(gap<=0)break, else gap=nums.size()/2
//按下標相隔gap進行分組， 對每一組進行直插排序。
*********************************************************************/
void shellsort(vector<int>& nums)
{
    int gap=nums.size()/2;
    while(gap>=1)
    {
        //對於第0,1,..gap-1組進行直插排序 
        for(int i=0;i<gap;i++)
        {
            //對 [j,j+gap,j+2gap,...]進行只直插排序
            for(int j=i;j<nums.size();j+=gap)
            {
                int insertpos=i,insertval=nums[j];
                while(nums[insertpos]<=nums[j] && insertpos<j)insertpos++;
                for(int k=j;k>insertpos;k--)nums[k]=nums[k-1];
                nums[insertpos]=insertval;
            }
        }
        gap/=2;
    }
}
/*********************************************************************
//直接選擇排序，后端維護一個有序序列，每次從未排序序列中找出一個最大值，
//與無序序列的最后一個元素交換位置
*********************************************************************/
void choosesort(vector<int>& nums)
{
    for(int i=0;i<nums.size();i++)
    {
        int maxpos=0,maxval=nums[0];//找出[0,nums.size()-i-1]中的最大值
        for(int j=0;j<nums.size()-i;j++)
            if(nums[j]>maxval)maxpos=j,maxval=nums[j];
        int temp=nums[nums.size()-1-i];
        nums[nums.size()-i-1]=maxval;nums[maxpos]=temp;
    }
}
/*********************************************************************
//堆排序，選擇排序的變種，利用一個大頂堆(升序排序)，保證根節點為最大元素，
//這樣一直與末尾交換並刪除，最終完成排序
//重點是大頂堆的維護 buildheap()
*********************************************************************/
//對於前n個元素，使其構成一個大頂堆
void buildheap(vector<int>& nums,int n)
{
    //從葉子往前找，若是葉子小於根，進行互換,序號為i的葉子其根序號為(i-1)/2
    for(int i=n-1;i>0;i--)
    {
        if(nums[i]>nums[(i-1)/2])
        {
            int temp=nums[i];
            nums[i]=nums[(i-1)/2];nums[(i-1)/2]=temp;
        }
    }
}

void heapsort(vector<int>& nums)
{
    for(int i=0;i<nums.size();i++)
    {
        buildheap(nums,nums.size()-i);//維護大頂堆
        int temp=nums[0];//交換首尾元素
        nums[0]=nums[nums.size()-i-1];nums[nums.size()-i-1]=temp;
    }
}

/*********************************************************************
冒泡排序
兩兩交換...
*********************************************************************/
void bubblesort(vector<int>& nums)
{
    for(int i=0;i<nums.size();i++)
        for(int j=i;j<nums.size();j++)
        {
            if(nums[j]<nums[i])
            {
                int temp=nums[i];
                nums[i]=nums[j];nums[j]=temp;
            }
        }
}
/*********************************************************************
快速排序，選取一個基准，一趟排序后，把大於基准的元素放在右邊，
小於它的元素放在左邊，一直下去直到排序完成。
*********************************************************************/
void quicksort(vector<int>& nums,int left,int right)
{
    if(left>=right)return;
    int l=left,r=right;
    int base=nums[l];
    while(l<r)
    {
        while(nums[r]>=base && l<r)r--;
        nums[l]=nums[r];
        while(nums[l]<=base && l<r)l++;
        nums[r]=nums[l];
    }
    nums[l]=base;
    quicksort(nums,left,l);
    quicksort(nums,l+1,right);
}

/*********************************************************************
歸並排序，
將已有序的子序列合並，得到完全有序的序列；
即先使每個子序列有序，再使子序列段間有序。
*********************************************************************/
void merge(vector<int>& nums, int left, int mid, int right)
{
    //對兩個有序序列作歸並處理
    int l = left, r = mid + 1;
    vector<int> arr;//歸並后的序列，等下更新到nums中
    while (l <= mid && r <= right)
    {
        if (nums[l] <= nums[r])
        {
            arr.push_back(nums[l++]);
        }
        else
        {
            arr.push_back(nums[r++]);
        }
    }
    while (l <= mid)arr.push_back(nums[l++]);
    while (r <= right)arr.push_back(nums[r++]);
    //arr更新到nums中
    for (int i = 0; i < arr.size(); i++)
        nums[left + i] = arr[i];
}

void mergesort(vector<int>& nums, int left, int right)
{
    if (right <= left)return;
    int mid = (right + left) / 2;
    //對分組的兩個序列進行歸並排序
    mergesort(nums, left, mid);
    mergesort(nums, mid + 1, right);
    //重點是歸並步驟，把兩個有序子序列合並成一個有序序列
    merge(nums, left, mid, right);
}

    vector<int> sortArray(vector<int>& nums) {
        
        quicksort(nums,0,nums.size()-1);

        return nums;
    }
};

 

class Solution {

public:

/********************************************************************

直接插入排序

數組前面維持一個有序區，每次從后面的無序區里選一個數插入到前面的有序區，直至全部已排序

*********************************************************************/

void insertsort(vector< int>& nums)

{

     for ( int i =  1; i < nums.size(); i++)

    {

         //找到插入位置

         int insertpos =  0, insertval = nums[i];

         while (nums[insertpos] <= nums[i] && insertpos<i)insertpos++;

         //挪動位置來插入

         for ( int j = i; j > insertpos; j--)

            nums[j] = nums[j -  1];

        nums[insertpos] = insertval; //插入

    }

}

/*********************************************************************

//希爾排序，直插排序的變形，執行以下循環:

//if(gap<=0)break, else gap=nums.size()/2

//按下標相隔gap進行分組， 對每一組進行直插排序。

*********************************************************************/

void shellsort(vector< int>& nums)

{

     int gap=nums.size()/ 2;

     while(gap>= 1)

    {

         //對於第0,1,..gap-1組進行直插排序 

         for( int i= 0;i<gap;i++)

        {

             //對 [j,j+gap,j+2gap,...]進行只直插排序

             for( int j=i;j<nums.size();j+=gap)

            {

                 int insertpos=i,insertval=nums[j];

                 while(nums[insertpos]<=nums[j] && insertpos<j)insertpos++;

                 for( int k=j;k>insertpos;k--)nums[k]=nums[k- 1];

                nums[insertpos]=insertval;

            }

        }

        gap/= 2;

    }

}

/*********************************************************************

//直接選擇排序，后端維護一個有序序列，每次從未排序序列中找出一個最大值，

//與無序序列的最后一個元素交換位置

*********************************************************************/

void choosesort(vector< int>& nums)

{

     for( int i= 0;i<nums.size();i++)

    {

         int maxpos= 0,maxval=nums[ 0]; //找出[0,nums.size()-i-1]中的最大值

         for( int j= 0;j<nums.size()-i;j++)

             if(nums[j]>maxval)maxpos=j,maxval=nums[j];

         int temp=nums[nums.size()- 1-i];

        nums[nums.size()-i- 1]=maxval;nums[maxpos]=temp;

    }

}

/*********************************************************************

//堆排序，選擇排序的變種，利用一個大頂堆(升序排序)，保證根節點為最大元素，

//這樣一直與末尾交換並刪除，最終完成排序

//重點是大頂堆的維護 buildheap()

*********************************************************************/

//對於前n個元素，使其構成一個大頂堆

void buildheap(vector< int>& nums, int n)

{

     //從葉子往前找，若是葉子小於根，進行互換,序號為i的葉子其根序號為(i-1)/2

     for( int i=n- 1;i> 0;i--)

    {

         if(nums[i]>nums[(i- 1)/ 2])

        {

             int temp=nums[i];

            nums[i]=nums[(i- 1)/ 2];nums[(i- 1)/ 2]=temp;

        }

    }

}

void heapsort(vector< int>& nums)

{

     for( int i= 0;i<nums.size();i++)

    {

        buildheap(nums,nums.size()-i); //維護大頂堆

         int temp=nums[ 0]; //交換首尾元素

        nums[ 0]=nums[nums.size()-i- 1];nums[nums.size()-i- 1]=temp;

    }

}

/*********************************************************************

冒泡排序

兩兩交換...

*********************************************************************/

void bubblesort(vector< int>& nums)

{

     for( int i= 0;i<nums.size();i++)

         for( int j=i;j<nums.size();j++)

        {

             if(nums[j]<nums[i])

            {

                 int temp=nums[i];

                nums[i]=nums[j];nums[j]=temp;

            }

        }

}

/*********************************************************************

快速排序，選取一個基准，一趟排序后，把大於基准的元素放在右邊，

小於它的元素放在左邊，一直下去直到排序完成。

*********************************************************************/

void quicksort(vector< int>& nums, int left, int right)

{

     if(left>=right) return;

     int l=left,r=right;

     int base=nums[l];

     while(l<r)

    {

         while(nums[r]>=base && l<r)r--;

        nums[l]=nums[r];

         while(nums[l]<=base && l<r)l++;

        nums[r]=nums[l];

    }

    nums[l]=base;

    quicksort(nums,left,l);

    quicksort(nums,l+ 1,right);

}

/*********************************************************************

歸並排序，

將已有序的子序列合並，得到完全有序的序列；

即先使每個子序列有序，再使子序列段間有序。

*********************************************************************/

void merge(vector< int>& nums,  int left,  int mid,  int right)

{

     //對兩個有序序列作歸並處理

     int l = left, r = mid +  1;

    vector< int> arr; //歸並后的序列，等下更新到nums中

     while (l <= mid && r <= right)

    {

         if (nums[l] <= nums[r])

        {

            arr.push_back(nums[l++]);

        }

         else

        {

            arr.push_back(nums[r++]);

        }

    }

     while (l <= mid)arr.push_back(nums[l++]);

     while (r <= right)arr.push_back(nums[r++]);

     //arr更新到nums中

     for ( int i =  0; i < arr.size(); i++)

        nums[left + i] = arr[i];

}

void mergesort(vector< int>& nums,  int left,  int right)

{

     if (right <= left) return;

     int mid = (right + left) /  2;

     //對分組的兩個序列進行歸並排序

    mergesort(nums, left, mid);

    mergesort(nums, mid +  1, right);

     //重點是歸並步驟，把兩個有序子序列合並成一個有序序列

    merge(nums, left, mid, right);

}

    vector< int> sortArray(vector< int>& nums) {

        

        quicksort(nums, 0,nums.size()- 1);

         return nums;

    }

};