算法分析：快速排序

快速排序（quicksort）是在实践中最快的已知排序算法。

平均运行时间是O（NlogN），最坏的情形是O（N^2）

算法之所以特别快，主要是由于非常精炼和高度优化的内部循环。

1.如果S中元素个数是0或1，则返回

2.取S中任1元素v，成为关键元（pivot）

3.将S-{v}（S中其余元素）划分成两个不想交的集合：左侧＜v，右侧≥v。

4.返回左侧的排序，后跟v，继而右侧的排序。

当子数组的长度小于10 的时候，使用了插入排序 算法分析：插入排序

//
//  Sort.h
//  HelloWorld
//  csdn blog：http://blog.csdn.net/u012175089
//  Created by feiyin001 on 17/1/11.
//  Copyright (c) 2017年 FableGame. All rights reserved.
//

#ifndef __HelloWorld__Sort__
#define __HelloWorld__Sort__
#include <vector>
using namespace std;
namespace Fable
{
    //选取关键的函数
    template<typename Comparable>
    const Comparable& median3(vector<Comparable>& a ,int left, int right)
    {
        int center = (left + right)/2;//中间的下标
        if (a[center] < a[left])
        {
            swap(a[left], a[center]);//将小的放在左侧
        }
        if (a[right] < a[left])
        {
            swap(a[left], a[right]);//将小的放在左侧
        }
        if (a[right] < a[center])
        {
            swap(a[center], a[right]);//将大的放在右侧
        }
        swap(a[center], a[right⑴]);//将中间值放在right⑴的位置
        return a[right⑴];//返回中间值
    }
    template<typename Comparable>
    void quicksort(vector<Comparable>& a, int left, int right)
    {
        if (left + 10 <= right)//这个子数组大于10，继续使用快速排序
        {
            Comparable pivot = median3(a, left, right);//关键值
            int i = left;//i指向左侧
            int j = right - 1;//j指向右侧，现在i和j都是已比较过的了，等下是先++和--
            while (true)
            {
                while (a[++i] < pivot) {}//小于关键值的元素是1直放在左侧，找出1个大的元素
                while (pivot < a[--j]) {}//大于关键值的元素是1直放在右侧，找出1个小的元素
                if (i < j)
                {
                    swap(a[i], a[j]);//i和j还没有交汇，交换位置
                }
                else
                {
                    break;//这个时候i指向的数是应当比关键值大的了
                }
            }
            swap(a[i], a[right - 1]);//将关键值放在i的位置
            quicksort(a, left, i - 1);//分别对关键值左侧的子数组排序
            quicksort(a, i + 1, right);//分别对关键值右侧的子数组排序
        }
        else
        {
            //使用插入排序，数组大小小于10的时候
            insertionSort(a.begin() + left, a.begin() + right + 1);
        }
    }
    //快速排序
    template <typename Comparable>
    void quicksort(vector<Comparable>& a)
    {
        quicksort(a, 0, a.size() - 1);
    }
}

#endif /* defined(__HelloWorld__Sort__) */