几种快速排序算法实现

快速排序是一种分治的递归算法，是在实践中最快的已知算法，平均运行时间为O（N logN）--logN每次需要随机选值（枢纽值）及左右部分枢纽值 --N左右快速排序。该算法有非常精炼和高度优化得内部循环。最坏性能为（N²）--每次选取随机数都是最大值或者最小值。

【1】普通递归实现　　--《剑指offer》何海涛

int Partition(int data[],int length,int start,int end)

{

　　if(data == nullptr || length <= 0 || start < 0 ||end >= length)

　　　　throw new std::exception("Invalid Parameters");



　　int index = RandomInRange(start,end);　　//随机选择数组中一个位置值

　　Swap(&data[index],&data[end]);　　　　　//将选出值放到末尾，为了从数组第0个值到倒数第二个值逐个和选出值比较大小（为啥不每次保留选出值，而是要交换到末尾去？？）



　　int small = start - 1;　　　　

　　for(index = start;index < end; ++index)　　//遍历数组

　　{

　　　　if(data[index] < data[end])　　//将比选出值小的值逐个排到从0开始的位置上

　　　　{

　　　　　　++small;　　　　　　　

　　　　　　if(small != index)　　　　//如果从0开始的值一直比选出值小,不做操作【例：值小，small=index=0,1,2,3,4。data[5]>data[end],此时index=5,small=4,data[6]<data[end],此时index=6,small=4,交换data[6]和data[4+1=5]】

　　　　　　　　Swap(&data[index],&data[small])

　　　　}

　　}

　　++small;

　　Swap(&data[small],&data[end]);　　//挑选出来的随机值被放入中间位置，此时左边值都比它小，右边值都比他大
　　

　　return small;

}

void QuickSort(int data[],int length,int start,int end)

{

　　if(start == end)

　　　　return;


　　int index = Partition(data,length,start,end);

　　if(index > start)

　　　　QuickSort(data,length,start,index-1);
　　if(index < end)

　　　　QuickSort(data,length,index +1,end);
}

【2】使用C++类和vector容器　　　　　　--《算法之美》 左飞

#ifndef QUICKSORT_H

#define QUICKSORT_H

#include<vector>

using namespace std;

class QuickSort

{

private:

　　int len;

　　vector<int> list;

public:

　　QuickSort(vector<int>_list,_len);

　　void quick_sort(int,int);

　　void swap(int,int);

　　void out();

};

#endif



#include "QuickSort.h"

#include <iostream>

using namespace std;



QuickSort::QuickSort(vector<int> _list,int _len)

{

　　for(int i=0;i<_len;i++)

　　　　list.push_back(_list[i]);

　　this->len = _len;

}

void QuickSort::quick_sort(int left,int right)

{

　　int i=left;

　　int j=right;

　　int pivot = list[left];

　　while(i<j)

　　{

　　　　while(i<j && list[j] >= pivot) j--;

　　　　if(i<j) swap(i,j);

　　　　while(i<j && list[i]<=pivot) i++;

　　　　if(i<j) swap(i,j);

　　}



　　if(j != left) quick_sort(left,i-1);

　　if(j != right) quick_sort(j+1,right);

}



void QuickSort::swap(int i,int j)

{

　　int temp=list[i];

　　list[i] = list[j];

　　list[j]=temp;

}

【3】使用模板和容器实现　　　　--《C++并发编程》Anthony Williams

template<typename T>

std::list<T> sequential_quick_sort(std::list<T> input)

{

　　if(input.empty())

　　　　return input;

　　std::list<T>　result;

　　result.splice(result.begin(),input,input.begin());　　//splice函数将数据传入容器中

　　T const& pivot = *result.begin();



　　auto divide_point=std::partition(input.begin(),input,input.end(),

　　　　　　　　[&](T const& t){return t<pivot;});　　　　//C++11新增，lambda函数

　　std::list<T> lower_part;

　　lower_part.splice(lower_part.end(),input,input.begin(),divide_point);

　　auto new_lower(sequential_quick_sort(std::move(lower_part)));

　　auto new_higher(seuqential_quick_sort(std::move(input)));

　　result.splice(result.end(),new_higher);

　　result.splice(resutlt.begina(),new_lower);

　　return result;

}

【4】使用模板容器future并行快速排序　　　　--《C++并发编程》Anthony Williams

template<typename T>
std::list<T> paraller_quick_sort(std::list<T> input)
{
　　if(input.empty())

　　　　return input;

　　std::list<T> result;

　　result.splice(result.begin(),input,input.begin());

　　T const& pivot = *result.begin();

　　auto divide_point=std::partition(input.begin(),input.end(),

　　　　　　[&] (T const& t){return t<pivot;});

　　std::list<T> lower_part;

　　lower_part.splice(lower_part.end(),input,input.begin(),divide_point);

　　std::future<std::list<T>> new_lower(std::async(&paraller_quicke_sort<T>,std::move(lower_part)));

　　auto new_higher(partition(std::move(input)));



　　result.splice(result.end(),new_higher);

　　result.splice(result.begin(),new_lower.get());

　　return result;
}