排序

选择排序：

template <typename Container>
void sort_selectSort_up(Container& container)
{
    typedef typename Container::iterator Iterator;
    Iterator iterBegin = container.begin();
    Iterator iterEnd = container.end();

    for(Iterator iter1 = iterBegin; iter1 != iterEnd; iter1++)
    {
        Iterator buf = iter1;
        for(Iterator iter2 = iter1; iter2 != iterEnd; iter2++)
        {
            if(*iter2 < *buf)       buf = iter2;
        }
        swap(*iter1, *buf);
    }
}

插入排序：

template <typename Container>
void sort_insertionsort(Container& container)
{
    typedef typename Container::iterator InputIterator;
    typedef typename Container::value_type value_type;

    InputIterator iterBegin = container.begin();
    InputIterator iterEnd = container.end();
    if(distance(iterBegin, iterEnd) < 2)    return;

    for(InputIterator iter = iterBegin + 1; iter != iterEnd; iter++)
    {
        InputIterator bufIter = iter;
        for(InputIterator iter2 = bufIter - 1; iter2 != iterBegin - 1; iter2--)
        {
            if(*bufIter < *iter2)
            {
                swap(*bufIter, *iter2);
                bufIter = iter2;
            }
            else                    break;
        }
        if(*bufIter < *iterBegin)       swap(*bufIter, *iterBegin);
    }
}

希尔排序：一种优化版本的插入排序，由于插入排序每次都是容器中两两元素之间的交换，那么有时候对于一个原本数据靠后排布的一个较小数据来说，他要移动到最前面需要移动较长次数，因此增大了每次移动数据的距离，然后使靠后位置较小的数据可以更小周期数的移动到前面，提升效率。

template <typename Container>
void sort_shellSort_up(Container& container)
{
    typedef typename Container::iterator Iterator;
    Iterator iterBegin = container.begin();
    Iterator iterEnd = container.end();

    int elementsNum = distance(iterBegin, iterEnd);
    int interval = 1;
    while(interval < elementsNum / 3)  interval = 3 * interval + 1;

    while(interval >= 1)
    {
        for(Iterator iter1 = iterBegin + interval; iter1 != iterEnd; iter1++)
        {
            Iterator buf = iter1;
            for(Iterator iter2 = iter1 - interval; iter2 >= iterBegin; iter2 -= interval)
            {
                if(*iter2 > *buf)
                {
                    swap(*iter2, *buf);
                    buf = iter2;
                }
                else break;
            }
        }
        interval /= 3;
    }
}

归并排序：归并本质上属于一种递归，将一个大的问题不断递归为小的问题，这里涉及到递归那就要找到一个递归节点，这个递归节点可以再次进行递归，然后在递归出口处理出口情况时的递归程序。

template <typename Iterator>
void mergeRange(Iterator iterBegin, Iterator iterMiddle, Iterator iterEnd)
{
    typedef typename Iterator::value_type value_type;
    int rangeNum1 = distance(iterBegin, iterMiddle);
    int rangeNum2 = distance(iterMiddle, iterEnd);
    if(rangeNum1 < 1 || rangeNum2 < 1)      return;

    value_type *range1 = new value_type[rangeNum1];
    value_type *range2 = new value_type[rangeNum2];

    int num1 = 0;
    for(Iterator iter = iterBegin; iter != iterMiddle; iter++)
    {
        range1[num1] = *iter;
        num1++;
    }

    int num2 = 0;
    for(Iterator iter = iterMiddle; iter != iterEnd; iter++)
    {
        range2[num2] = *iter;
        num2++;
    }

    num1 = num2 = 0;
    for(Iterator iter = iterBegin; iter != iterEnd; iter++)
    {
        if(num1 >= rangeNum1)
        {
            *iter = range2[num2];
            num2++;
        }
        else if(num2 >= rangeNum2)
        {
            *iter = range1[num1];
            num1++;
        }
        else if(range1[num1] < range2[num2])
        {
            *iter = range1[num1];
            num1++;
        }
        else
        {
            *iter = range2[num2];
            num2++;
        }
    }

    delete[] range1;
    delete[] range2;
}

template <typename Iterator>
void sort_mergeSort_up(Iterator iterBegin, Iterator iterEnd)
{
    int num = distance(iterBegin, iterEnd);
    if(num < 2)     return;

    int middle = num / 2;
    Iterator iterMiddle = next(iterBegin, middle);

    sort_mergeSort_up(iterBegin, iterMiddle);
    sort_mergeSort_up(iterMiddle, iterEnd);
    mergeRange(iterBegin, iterMiddle, iterEnd);
}

template <typename Container>
void sort_mergeSort_up(Container& container)
{
    sort_mergeSort_up(container.begin(), container.end());
}

快速排序(切分排序)：整体是个迭代的过程，对于一个范围，选择一个迭代标准进行切分，直到最后没有区域(元素少于两个)可以再进行切分位置。

需要注意的是对于一次切分操作后，partitionRange返回迭代器指向切分标准，这个切分标准的最终位置已经确认，就是该位置，且之后也不应该再将其进行迭代，很有可能会出现迭代标准一直是该位置导致程序陷入死循环；

template <typename Iterator>
Iterator partitionRange(Iterator iterBegin, Iterator iterMiddle, Iterator iterEnd)
{
    typedef typename Iterator::value_type value_type;
    value_type value = *iterMiddle;

    Iterator lt = iterBegin;
    Iterator gt = iterEnd - 1;
    for(Iterator iter = iterBegin; iter != gt + 1; iter++)
    {
        if(*iter < value)
        {
            swap(*iter, *lt);
            lt++;
        }
        else if(*iter > value)
        {
            swap(*iter, *gt);
            gt--;
            iter--;
        }
    }
    return lt;

//    int num = distance(iterBegin, iterEnd);
//    value_type *value = new value_type[num];

//    int numBegin = 0;
//    int numEnd = num - 1;
//    for(Iterator iter = iterBegin; iter != iterEnd; iter++)
//    {
//        if(iter != iterMiddle)
//        {
//            if(*iter < *iterMiddle)     value[numBegin++] = *iter;
//            else                        value[numEnd--] = *iter;
//        }
//    }
//    value[numBegin] = *iterMiddle;

//    numEnd = 0;
//    for(Iterator iter = iterBegin; iter != iterEnd; iter++)
//    {
//        *iter = value[numEnd++];
//    }
//    delete[] value;
//    return (iterBegin + numBegin);
}

template <typename Iterator>
void sort_quickSort_up(Iterator iterBegin, Iterator iterEnd)
{
    int num = distance(iterBegin, iterEnd);
    if(num < 2)     return;

    Iterator iterMiddle = partitionRange(iterBegin, iterBegin, iterEnd);

    int beginNum = distance(iterBegin, iterMiddle);
    int endNum = distance(iterMiddle, iterEnd);
    if(beginNum > 1)        sort_quickSort_up(iterBegin, iterMiddle);
    if(endNum > 1)          sort_quickSort_up(iterMiddle + 1, iterEnd);
}

template <typename Container>
void sort_quickSort_up(Container& container)
{
    typedef typename Container::iterator Iterator;
    Iterator iterBegin = container.begin();
    Iterator iterEnd = container.end();
    sort_quickSort_up(iterBegin, iterEnd);
}

堆排序：建堆，然后不断pop堆；

template <typename Container>
void sort_heapSort_up(Container& container)
{
    typedef typename Container::iterator Iterator;
    Iterator iterBegin = container.begin();
    Iterator iterEnd = container.end();
    make_heap(iterBegin, iterEnd);
    for(Iterator iter = iterBegin; iter != iterEnd; iter++)     pop_heap(iterBegin, iterEnd);
}