泛型,Quick Sort 的C/C++两种实现方式

最新推荐文章于 2024-03-29 15:31:23 发布

manthink2005

最新推荐文章于 2024-03-29 15:31:23 发布

阅读量664

点赞数

CC 4.0 BY-SA版权

文章标签：泛型 c++ c algorithm

本文链接：https://blog.youkuaiyun.com/manthink2005/article/details/23861395

本文介绍了快速排序算法的原理及其在C/C++中的实现方式。快速排序是一种高效的排序算法，采用分治策略，将待排序的数组分成较小的子数组进行递归排序。文章提供了两种实现方法，一种是C++模板实现，另一种是C语言通用版本。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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