泛型,Quick Sort 的C/C++兩種實現方式

Quick Sort 作爲20世紀的10大算法，實現的算法思想爲分治策略（Divide And Conquer)。分治策略這種思想是程序設計中最常用到的思想。它的基本思想是把原問題遞歸劃分爲若干個子問題，通過分別求解子問題（相對簡單情況），然後組合這些子問題的解，從而形成原問題的解。本文，分別用C/C++實現泛型的Quick Sort，具體代碼如下：

#ifndef _MERGE_SORT_H_
#define _MERGE_SORT_H_

#define  MAXLEN  65535

#include <functional>
#include <algorithm>
#include <iostream>

/*
* swap data object for c++ implementation of quick sort
*
*/
template<class T>
void SwapObj( T& first, T& second )
{
	T temp = first;
	first = second;
	second = temp;
}

/*
* c++ implementation of generic quick sort
*
*/
template<class T>
int PartitionCPlus( T item[], int left, int right )
{
	int i = left - 1;
	int j = right;
	T   pivot = item[right];

	while( i <= j )
	{
		while( item[++i] < pivot );

		while( item[--j] > pivot )
		{
			if( j <= i )
				break;
		}

		if(  j <= i )
			break;

		SwapObj( item[i], item[j] );
	}

	SwapObj( item[i],  item[right] );

	return i;
}

/*
* interface of c++ implementation of generic quick sort
*
*/
template<class T>
void QuickSortCPlus( T item[], int left, int right )
{
	if( left >= right )
		return;

	int mid = PartitionCPlus( item, left, right );
	QuickSortCPlus( item, left, mid - 1 );
	QuickSortCPlus( item, mid + 1, right );
}


/*
* swap data object for c implementation of quick sort
*
*/
void SwapCharBuffer( void* first, void* second, size_t elemSize )
{
	char* buf = (char*)malloc(elemSize);
	assert( buf );

	memcpy( buf, (char*)first, elemSize );
	memcpy( first, second, elemSize );
	memcpy( second, buf, elemSize );

	free( buf );
}

/*
* c implementation of generic quick sort
*
*/
void ImplQuickSortC( void* item, size_t elemSize, int (*cmp)( void* first, void* second ), int start, int end )
{
	if( start >= end )
		return;

	void* pivot = (char*)item + start;
	int i = start + elemSize;
	int j = end;

	while( i < j )
	{
		if( cmp( (char*)item + i, pivot ) <= 0 )
		{
			i += elemSize;
		}
		else
		{
			j -= elemSize;
			SwapCharBuffer( (char*)item + i, (char*)item + j, elemSize );
		}
	}

	i -= elemSize;
	SwapCharBuffer( (char*)item + start, (char*)item + i, elemSize );

	ImplQuickSortC( item, elemSize, cmp, start, i );
	ImplQuickSortC( item, elemSize, cmp, j, end );
}

/*
* interface function of c implementation of generic quick sort
*
*/
void QuickSortC( void* item, size_t elemCount, size_t elemSize, int (*cmp)( void* first, void* second ) )
{
	ImplQuickSortC( item, elemSize, cmp, 0, (elemCount)*elemSize );
}


int CmpFunc( void* first, void* second )
{
	return *(int*)first - *(int*)second;
}

template<class T>
void Output( const T item[], size_t len )
{
	std::cout << "output result as follows:" << std::endl;

	int intervalLen = 10;

	for( int i= 0; i < len; i++ )
	{
		if( 0 == i || (i %  10) )
		{
			std::cout<< item[i] << " ";
		}
		else
		{
			std::cout << std::endl;
			std::cout << item[i] << " ";
		}
	}

	std::cout << std::endl;
}


void TestQuickSortC()
{
	const int maxLen = 100;
	int item[maxLen];
	for( int i = 0; i < maxLen; i++ )
	{
		item[i] = i;
	}

	std::random_shuffle( item, item + maxLen );

	QuickSortC( item, maxLen, sizeof(int), CmpFunc);

	Output( item, maxLen );
}


void TestQuickSortCPlus()
{
	const int maxLen = 100;
	int item[maxLen];
	for( int i = 0; i < maxLen; i++ )
	{
		item[i] = i;
	}

	std::random_shuffle( item, item + maxLen );

	QuickSortCPlus( item, 0, maxLen - 1 );

	Output( item, maxLen );
}



#endif