内部排序算法及排序复杂度

各类排序算法时间复杂度和空间复杂度及稳定性分析
(https://img-blog.csdn.net/20170421232053675?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvbm9fd2E=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
排序类模板，这里使用的基本数据类型所以没有定义compare函数

//SORT_H
#ifndef SORT_H
#define SORT_H

#include <vector>
#include <iostream>
#include <string>

using namespace std;

template<typename Comparable>
class Sort
{
private:
    int selectMin(int index)
    {
        int ret;
        Comparable x = arrays[index];
        for(int i = index + 1; i < arrays.size(); ++i)
            if(x < arrays[i])
                ret = i;
        return ret;
    }

    int partition(int left, int right)
    {
        Comparable x = arrays[left];
        while(left < right)
        {
            while(left < right && arrays[right] >= x)   right--;
            swap(arrays[left], arrays[right]);
            while(left < right && arrays[left] <= x)    left++;
            swap(arrays[left], arrays[right]);
        }
        arrays[left] = x;
        return left;

    }

    void quickSort(int left, int right)
    {
        if(left < right)
        {
            int pivotloc = partition(left, right);
            quickSort(left, pivotloc - 1);
            quickSort(pivotloc + 1, right);
        }
    }

    void percolateDown(int index, int n)
    {
        int x = arrays[index];
        int child;
        for(; index * 2 + 1 < n; index = child)
        {
            child = 2 * index + 1;
            if(child + 1 < n && arrays[child+1] > arrays[child] )
                child++;
            if(arrays[child] > x)
                arrays[index] = arrays[child];
            else
                break;
        }
        arrays[index] = x;
    }

    void merge(vector<Comparable> &tmpArray, int leftPos, int rightPos, int rightEnd)
    {
        int leftEnd = rightPos - 1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;

        while(leftPos <= leftEnd && rightPos <= rightEnd)
        {
            if(arrays[leftPos] <= arrays[rightPos])
                tmpArray[tmpPos++] = arrays[leftPos++];
            else
                tmpArray[tmpPos++] = arrays[rightPos++];
        }

        while(leftPos <= leftEnd)
            tmpArray[tmpPos++] = arrays[leftPos++];
        while(rightPos <= rightEnd)
            tmpArray[tmpPos++] = arrays[rightPos++];

        for(int i = 0; i < numElements; ++i, --rightEnd)
            arrays[rightEnd] = tmpArray[rightEnd];
    }

    void mergeSort(vector<Comparable> &tmpArray, int left, int right)
    {
        if(left < right)
        {
            int center = (left + right) / 2;
            mergeSort(tmpArray, left, center);
            mergeSort(tmpArray, center + 1, right);
            merge(tmpArray, left, center + 1, right);
        }
    }

public:
    Sort(const vector<Comparable> &v) : arrays(v) { }
    Sort(const Sort<Comparable> &rhs) : arrays(rhs.arrays) { }
    friend ostream& operator << (ostream& out, const Sort<Comparable> &s)
    {
        for(int i = 0; i < s.arrays.size(); ++i)
            out << s.arrays[i] << " ";
        return out;
    }
    //void printArray() const { cout << *this; }
    // 冒泡排序时间复杂度O(n^2) 空间复杂度O(1)
    void bubbleSort()
    {
        for(int i = 0; i < arrays.size() - 1; ++i)
            for(int j = 0; j < arrays.size() - 1 - i; ++j)
            {
                if(arrays[j] > arrays[j+1])   //若为内部数据类型可以直接比较 否则调用compare函数
                    swap(arrays[j], arrays[j+1]);
            }

    }

    //插入排序时间复杂度O(n^2) 空间复杂度O(1)
    void insertSort()
    {
        int j;
        for(int i = 1; i < arrays.size(); ++i)
        {
            Comparable x = arrays[i];
            for(j = i; j > 0 && arrays[j-1] > x; --j)
                arrays[j] = arrays[j-1];
            arrays[j] = x;
        }
    }

    void shellSort()
    {
        for(int gap = arrays.size() / 2; gap > 0; gap >>= 1)
        {
            for(int i = gap; i < arrays.size(); ++i)
            {
                Comparable x = arrays[i];
                int j = i;
                for(; j >= gap && arrays[j-gap] > x; j -= gap)
                    arrays[j] = arrays[j-gap];
                arrays[j] = x;
            }
        }
    }

    //选择排序时间复杂度O(n^2) 空间复杂度O(1)
    void selectSort()
    {
        for(int i = 0; i < arrays.size() - 1; ++i)
            swap(arrays[i], arrays[selectMin(i)]);
    }

    void quickSort()
    {
        quickSort(0, arrays.size() - 1);
    }

    void heapSort()
    {
        for(int i = (arrays.size() - 1) / 2 ; i >= 0; --i)
            percolateDown(i, arrays.size());
            /*
        for(int i = 0; i < arrays.size(); ++i)
            cout << arrays[i] << " ";
        */
        //cout << endl;
        int sz = arrays.size() - 1;
        for(; sz > 0; sz--)
        {
            swap(arrays[0], arrays[sz]);
            //printf("%d ", arrays[sz]);
            percolateDown(0, sz);
            /*
            for(int i = 0; i < arrays.size(); ++i)
                cout << arrays[i] << " ";
            cout << endl;
            */
        }
    }

    void mergeSort()
    {
        vector<Comparable> tmpArray(arrays.size());
        mergeSort(tmpArray, 0, arrays.size() - 1);
    }
private:
    vector<Comparable> arrays;
};
#endif // SORT_H

测试

#include "Sort.h"

int main(int argc, char *argv[])
{
    vector<int> v{5, 9, 10, 3, 6, 2, 6, 18};
    Sort<int> s(v), t(v);
    cout << "原序列：" << s << endl;
    s.bubbleSort();
    cout << "冒泡排序：" << s << endl;
    s = t;
    s.insertSort();
    cout << "插入排序：" << s << endl;
    s = t;
    s.quickSort();
    cout << "快速排序：" << s << endl;
    s = t;
    s.heapSort();
    cout << "堆排序：" << s << endl;
    s = t;
    s.mergeSort();
    cout << "归并排序：" << s << endl;
    s = t;
    s.shellSort();
    cout << "谢尔排序：" << s << endl;
    return 0;
}