常见的几种排序算法

#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
    //两端向中间靠拢  
    int partition1(vector<int> &array, int left, int right)
    {
      int pivot = array[left];
      int p = left;
      int q = right;
      while(p < q)
      {
          while(p < q && array[q] >= pivot) q--;
            array[p] = array[q];
          while(p < q && array[p] <= pivot) p++;
            array[q] = array[p];
      }
      array[p] = pivot;
      return p;
    }
    void swap(int & a, int &b)
    {
        int x = a;
        a = b;
        b = x;
    }
    //与小集边界交换
    int partition(vector<int> &array, int left, int right)
    {
        int i = left;
        int j = i + 1;
        int pivot = array[i];
        for(; j <= right; j++)
        {
            if(array[j] < pivot)
            {
                swap(array[i + 1], array[j]);
                i++;
            }
        }
        swap(array[left],array[i]);
        return i;
    }
    //快速排序
    void quicksort(vector<int> &array, int left, int right) {
        if(left < right)
        {
            int mid = partition(array, left, right);
            quicksort(array, left, mid - 1);
            quicksort(array, mid + 1, right);
        }
    }
    void print(vector<int> &array)
    {
        for(int i = 0; i < array.size(); i++)
            cout << array[i] << " ";
        cout << endl;
    }
    //冒泡排序
    void bubblingsort(vector<int> &array)
    {
        vector<int>::size_type size = array.size();
        typedef vector<int>::size_type sz_type;
        for(sz_type i = 1 ; i < size; i++)
            for(sz_type j = 0; j < size - i; j++)
            {
                if(array[j] > array[j + 1])
                    swap(array[j], array[j + 1]);
            }
    }
    //插入排序
    void insertsort(vector<int> &array)
    {
        vector<int>::size_type size = array.size();
        typedef vector<int>::size_type sz_type;
        int j;
        int pivot;
        for(sz_type i = 1 ; i < size; i++)
        {
            if(array[i] < array[i - 1])
            { 
                j = i - 1;
                pivot = array[i];
                do 
                {
                    array[j + 1] = array[j];
                    j--;
                } while (j >= 0 && pivot < array[j]);
                array[j + 1] = pivot;
            }
        }
    }
    //归并
    void merge(vector<int> &array,int left, int mid, int right)
    {
        int p = left, q = mid + 1;
        vector<int> temp;
        while(p <= mid && q <= right)
        {
            if(array[p] <= array[q])
                temp.push_back(array[p++]);
            else
                temp.push_back(array[q++]);
        }
        while(p <= mid)
            temp.push_back(array[p++]);
        while(q <= right)
            temp.push_back(array[q++]);
        int size = temp.size();
        for (int i = 0; i < size; i++)
            array[left++] = temp[i];
    }
    //归并排序
    void mergesort(vector<int> &array ,int left, int right)
    {
        if(left < right)
        {
            int mid = (left + right) / 2;
            mergesort(array, left, mid);
            mergesort(array, mid + 1, right);
            merge(array, left, mid, right);
        }
    }

};