快速排序 [Algorithm]

杂谈：指针和数组

    对于数组编译器可以自动推到出内部元素的大小，可以通过sizeof或者模板，

     //1 int myints[] = {10,20,30,5,15}; int length = sizeof(myints)/sizeof(myints[0]); //2 template <typename T,int size> int GetArraySize(T (&ptr)[size]) { return size; } GetArraySize(myints);

     但是指针，则不能通过模板或者sizeof推到出尺寸大小，原因在于sizeof和模板都是在编译期起作用~ 

      int* ptr = new int[5]; sizeof(ptr) == 5; //true GetArraySize(ptr); //参数不匹配

     所以使用模板写排序函数时候，为了兼容指针和数组，要么传首指针和size，要么像STL中的传首位指针。本文使用前者。

快速排序

    快速排序是最实用的排序方法，虽然它最坏运行时间为O(n^2), 但是它的平均期望运行时间为O(nlgn)，std::sort在元素个数小于32的情况下使用的就是quick_sort排序（大于32则使用堆排序）。

    快速排序的核心思想是将数组划分为三部分，如果大到小顺序排序，则一次划分将数组分为小于枢轴值的区间，等于枢轴值，大于枢轴值的区间。然后分段递归划分。

    代码如下：

#include <iostream> #include <algorithm> #include <limits> #include <vector> #include <ctime> #include <cassert> using namespace std; // Avoid collide with std::swap. void swap(int& a, int& b) { typedef int type; type temp = a; a = b; b = temp; } template<typename _Ty> int quick_partition(_Ty* ptr, int begin, int end, int length/*for debug*/) { typedef _Ty type; typedef type* ptr_type; type pivot = ptr[end]; // compare value. int section1 = begin-1; // first section index. #ifdef _DEBUG cout << "----------------------------------------------" << endl; cout << "Pivot is = " << pivot << endl; cout << "Before partition : "; for (int i(0); i<length; i++) cout << ptr[i] << " "; cout << endl; #endif for (int idx = begin; idx<end; idx++) { if (ptr[idx]<=pivot) //逆序排序，改为ptr[idx]>=pivot { section1++; swap( ptr[section1], ptr[idx] ); #ifdef _DEBUG cout << "Swap : " << section1 << " " << idx << endl; #endif } } swap( ptr[section1+1], ptr[end] ); #ifdef _DEBUG cout << "After partition : "; for (int i(0); i<length; i++) if (i==section1+1) cout << "{" << ptr[i] << "}" << " "; else cout << ptr[i] << " "; cout << endl; cout << "----------------------------------------------" << endl; #endif return section1+1; } template<class _Ty> void quick_sort(_Ty* ptr, int begin, int end, int length/*for debug*/) { if (begin>end) return; int size = sizeof(ptr)/sizeof(ptr[0]); int pos = quick_partition(ptr, begin, end, length); quick_sort(ptr, begin, pos-1, length); quick_sort(ptr, pos+1, end, length); } template<typename _Ty> void stooge_sort(_Ty* ptr, int begin, int end) { if (ptr[begin] > ptr[end]) swap(ptr[begin], ptr[end]); if (begin+1>=end) return; int k = (end-begin+1)/3; stooge_sort(ptr, begin, end-k); stooge_sort(ptr, begin+k, end); stooge_sort(ptr, begin, end-k); } int main () { #define P_1 #ifdef P_1 { int myints[] = {10,20,30,5,15}; int length = sizeof(myints)/sizeof(myints[0]); int* p = new int[5]; quick_sort(myints, 0, length-1, length); //stooge_sort(myints, 0, length-1); for (int i(0); i<length; i++) cout << myints[i] << " "; cout << endl; } #endif // P_1 #ifdef P_2 { const int test_num = 1000000; // 1 million srand((int)time(0)); cout << "Test number " << "/t:/t/t" << test_num << std::endl; int* testPtr = new int[test_num]; int* testPtr1 = new int[test_num]; for(int idx=0; idx<test_num; idx++) testPtr1[idx] = testPtr[idx] = rand(); clock_t t = clock(); quick_sort(testPtr, 0, test_num-1, test_num); //stooge_sort(testPtr, 0, test_num-1); cout << "heap_sort " << "/t:/t/t" << clock() - t << std::endl; t = clock(); std::sort(testPtr1, testPtr1+test_num); cout << "std::sort_heap " << "/t:/t/t" << clock() - t << std::endl; // Test the result validity for(int idx=0; idx<test_num; idx++) if (testPtr[idx]!=testPtr1[idx]) cout << "wrong"; delete[] testPtr; testPtr = 0; delete[] testPtr1; testPtr1 = 0; } #endif // P_2 #ifdef P_3 #endif // P_3 system("PAUSE"); return 0; }

    在debug模式下，输出快速排序过程：

---------------------------------------------- Pivot is = 15 Before partition : 10 20 30 5 15 Swap : 0 0 Swap : 1 3 After partition : 10 5 {15} 20 30 ---------------------------------------------- ---------------------------------------------- Pivot is = 5 Before partition : 10 5 15 20 30 After partition : {5} 10 15 20 30 ---------------------------------------------- ---------------------------------------------- Pivot is = 10 Before partition : 5 10 15 20 30 After partition : 5 {10} 15 20 30 ---------------------------------------------- ---------------------------------------------- Pivot is = 30 Before partition : 5 10 15 20 30 Swap : 3 3 After partition : 5 10 15 20 {30} ---------------------------------------------- ---------------------------------------------- Pivot is = 20 Before partition : 5 10 15 20 30 After partition : 5 10 15 {20} 30 ---------------------------------------------- 5 10 15 20 30

后记

    如果要逆序从大到小排序，只需要修改划分函数中的if比较表达式，或者像STL中传入一个函数指针进去。导论中提到了一个stooge_sort排序算法，效率实在是低~

快排分区算法常见的是：双边交换的算法。

分区算法-2011-9-15

int partition(int* ptr, int beg, int end)
{
	int povit = ptr[beg];

	int h = beg;

	for (int k=h; k<=end; k++)
	{
		if (ptr[k] < povit)
		{
			h = h+1;
			swap(ptr[h], ptr[k]);
		}
	}
	swap( ptr[h], ptr[beg] );

	return h;
}

int double_partition(int* ptr, int beg, int end)
{
	int h = beg;
	int k = end;

	int povit = ptr[beg];

	while ( h < k)
	{
		while (h < k && ptr[k] > povit)
			--k;
		
		ptr[h] = ptr[k];

		while (h < k && ptr[h] < povit)
			++h;

		ptr[k] = ptr[h];
	}
	
	ptr[h] = povit;

	return h;	
}

int select_kth_element(int* ptr, int beg, int end, int kth)  
{  
	if (beg > end)  
		return -1;  


	//  int pos = partition(ptr, beg, end);  
	int pos = double_partition(ptr, beg, end);  
/*
	if (pos == kth)				// 直接位置比较
		return ptr[pos];  
	else if (pos > kth)  
		return select_kth_element(ptr, beg, pos-1, kth);  


	return select_kth_element(ptr, pos+1, end, kth);  
*/
	int offset = pos - beg;		// 偏移量比较
	if (offset == kth)  
		return ptr[pos];  
	else if (offset > kth)  
		return select_kth_element(ptr, beg, pos-1, kth); 
	// k - (offset+1)
	return select_kth_element(ptr, pos+1, end, kth-offset-1);  
}