目录

1、插入排序

2、冒泡排序

3、选择排序

4、希尔排序

5、快排（2路）

6、堆排序

7、归并排序

1、插入排序

template <typename T>
void insertSort(vector<T>& v)
{
    if( v.empty() )
        return;
    for( size_t i=1;i<v.size();i++ )
    {
        T temp = v[i];
        int j;
        for( j=i;j>0&&v[j-1]>temp;j-- )
            v[j] = v[j-1];
        v[j] = temp;
    }

    return;
}

2、冒泡排序

template <typename T>
void bubbleSort(vector<T>& v)
{
    int len = v.size();
    for( int i=0;i<len-1;i++ )
    {
        for( int j=0;j<len-i-1;j++ )
            if( v[j] > v[j+1] )
                swap(v[j],v[j+1]);
    }

    return;
}

3、选择排序

template <typename T>
void selectSort(vector<T>& v)
{
    int len = v.size();
    for( int i=0;i<len;i++ )
    {
        int index = i;
        for( int j=i+1;j<len;j++ )
        {
            if( v[j] < v[index] )
                index = j;
        }
        swap(v[i],v[index]);
    }
    return;
}

4、希尔排序

template <typename T>
void shellSort(vector<T>& v)
{
    int len = (int)(v.size());
    int gap = len/2;
    while( gap > 0 )
    {
        for( int i=0;i<gap;i++ ) // i是第一个元素下标
        {
            for( int j=i+gap;j<len;j+=gap )
            {
                T temp = v[j];
                int k = j - gap;
                while( k >= 0 && temp < v[k] )
                {
                    v[k+gap] = v[k];
                    k -= gap;
                }
                v.at(k+gap) = temp;
            }
        }
        gap /= 2;
    }
    return;
}

5、快排（2路）

template <typename T>
void _quickSort2Way(vector<T>& v, int left, int right)
{
    if( left >= right )
        return;
    swap(v[left],v[rand()%(right-left+1) + left]);
    int i = left+1;
    int j = right;
    while( i <= j ) // <=
    {
        while( v[i] < v[left] )
            i++;
        while( v[j] > v[left] )
            j--;
        if( i >= j )
            break;
        swap(v[i], v[j]);
        i++; // 这里别忘了
        j--;
    }
    swap(v[i-1], v[left]); // 这里是i-1
    _quickSort2Way(v, left, i-2);
    _quickSort2Way(v, i, right);

    return;
}

template <typename T>
void quickSort2Way(vector<T>& v)
{
    _quickSort2Way(v, 0, v.size()-1);
    return;
}

6、堆排序

template <typename T>
void down(vector<T>& v, int i, int n)
{
    //只需要保证有左孩子，如果没有，啥都不用做
    while(2*i+1 < n)
    {
        int k = 2*i+1;
        //如果有右孩子，就和左孩子比一下，选择更大的孩子
        if(k+1 < n && v[k] < v[k+1])
            k += 1;

        if(v[i] < v[k]) {
            swap(v[i], v[k]);
            i = k;
        }
        else
            break;
    }
}

template <typename T>
void heapify(vector<T>& v)
{
    int len = v.size();
    for( int i=len/2-1;i>=0;i-- )
        down(v, i, len);

    return;
}

template <typename T>
void heapSort(vector<T>& v)
{
    int len = v.size();
    heapify(v);
    for( int i=len-1;i>0;i-- )
    {
        swap(v[0], v[i]);
        down(v, 0, i);
    }
    return;
}

7、归并排序

template <typename T>
void _mergeSort(vector<T>& v, vector<T>& aux, int left, int right)
{
    if( left >= right )
        return;

    int mid = left + (right-left)/2;
    _mergeSort(v, aux, left, mid);
    _mergeSort(v, aux, mid+1, right);

    for( int i=left;i<=right;i++ )
        aux[i] = v[i];

    int i = left;
    int j = mid + 1;
    int k = left;

    while(1)
    {
        if( i > mid && j > right )
            break;
        else if( i > mid )
        {
            while( j <= right )
            {
                v[k] = aux[j];
                k++;
                j++;
            }
        }
        else if( j > right )
        {
            while( i <= mid )
            {
                v[k] = aux[i];
                k++;
                i++;
            }
        }
        else if( aux[i] <= aux[j] )
        {
            v[k] = aux[i];
            k++;
            i++;
        }
        else
        {
            v[k] = aux[j];
            k++;
            j++;
        }
    }

    return;
}

template <typename T>
void mergeSort(vector<T>& v)
{
    vector<T> aux(v.size());
    _mergeSort(v, aux, 0, v.size()-1);
    return;
}