数据结构与算法分析之--->部分排序算法的实现

冒泡 选择 插入 归并 堆排 快排 希尔

/*  Sort Rate Study			          */
/*  Author: ZZ_Inori_Evanescence/Elapsed_Hiyori	  */
/*  Home: http://blog.csdn.net/Elapsed_Hiyori	  */
/*  Date: 2012/12/16  10:57			  */
/*  ***********************************************/


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>

#define FALSE	0
#define TRUE	1
#define ElementType int
#define MAXNUM 100000


/* ========================================= */
/* Random Numbers;
/* ========================================= */

ElementType *GetRandomNumbers( void ){

	int i;
	ElementType *TempArray;

	TempArray = ( ElementType * )malloc( MAXNUM * sizeof( ElementType ) );

	for( i = 0; i < MAXNUM; i++ )
		TempArray[i] = rand() % 999999;

	return TempArray;
}


/* ========================================= */
/* Swap;
/* ========================================= */

void Swap( int *a, int *b ){

	int TempCell;

	TempCell = *a;
	*a = *b;
	*b = TempCell;
}


/* ========================================= */
/* Bubble Sort;
/* ========================================= */

void BubbleSort( ElementType *Array, int n ){

	int i, LastExchangeIndex,j;

	i = n-1;

	while( i > 0 ){

		LastExchangeIndex = 0;

		for( j = 0; j < i; j++ )
			if( Array[j+1] < Array[j] ){

				Swap( &Array[j+1], &Array[j]  );
				LastExchangeIndex = j;

			}

			i = LastExchangeIndex;
	}
}


/* ========================================= */
/* Select Sort;
/* ========================================= */

void SelectSort( ElementType *Array, int n ){

	int i,j,min;

	for( i = 0; i < n-1; i++ ){

		int Index = 0;
		min = Array[i];

		for( j = i+1; j < n; j++ ){

			if( Array[j] < min ){

				min = Array[j];
				Index = j;
			}
		}

		if( Index ){

			Swap( &Array[Index], &Array[i] );
		}
	}

}

/* ========================================= */
/* Insertion Sort;
/* ========================================= */

void InsertionSort( ElementType *Array, int n ){

	int j,P;

	ElementType TempCell;

	for( P = 1; P < n; P++ ){

		TempCell = Array[P];
		for( j = P; j > 0 && Array[j-1] > TempCell; j-- )
			Array[j] = Array[j-1];
		Array[j] = TempCell;
	}
}

/* ========================================= */
/* Shell Sort;
/* Increment Sequence: Shell Sequence;
/* ========================================= */

void ShellSort( ElementType *Array, int n ){

	int i,j,Increment;
	ElementType TempCell;

	for( Increment = n/2; Increment > 0; Increment /= 2 )
		for( i = Increment; i < n; i++ ){

			TempCell = Array[i];
			for( j = i; j >= Increment; j -= Increment )
				if( TempCell < Array[j-Increment] )
					Array[j] = Array[j-Increment];
				else
					break;

			Array[j] = TempCell;
		}

}

/* ========================================= */
/* Heap Sort;
/* ========================================= */

#define LeftChild( i ) ( 2 * ( i ) + 1 )

void PercDown( ElementType *Array, int i, int n ){

	int Child;
	ElementType TempCell;

	for( TempCell = Array[i]; LeftChild( i ) < n; i = Child ){

		Child = LeftChild( i );
		if( Child != n-1 && Array[Child+1] > Array[Child] )
			Child++;
		if( TempCell < Array[Child] )
			Array[i] = Array[Child];
		else
			break;
	}

	Array[i] = TempCell;
}

void HeapSort( ElementType *Array, int n ){

	int i;

	for( i = n/2; i >= 0; i-- )  /* BuildHeap */
		PercDown( Array, i, n );

	for( i = n-1; i > 0; i-- ){

		Swap( &Array[0], &Array[i] );
		PercDown( Array, 0, i );
	}
}

/* ========================================= */
/* Merge Sort;
/* ========================================= */

void Merge( ElementType *Array, ElementType *TempArray,
					int Lpos, int Rpos, int RightEnd ){

	int i, LeftEnd, NumElements, TempPos;

	LeftEnd = Rpos - 1;
	TempPos = Lpos;

	NumElements = RightEnd - Lpos + 1;

	while( Lpos <= LeftEnd && Rpos <= RightEnd )
		if( Array[Lpos] <= Array[Rpos] )
			TempArray[TempPos++] = Array[Lpos++];
		else
			TempArray[TempPos++] = Array[Rpos++];

	while( Lpos <= LeftEnd )
		TempArray[TempPos++] = Array[Lpos++];
	while( Rpos <= RightEnd )
		TempArray[TempPos++] = Array[Rpos++];

	for( i = 0; i < NumElements; i++, RightEnd-- )
		Array[RightEnd] = TempArray[RightEnd];
}

void Msort( ElementType *Array, ElementType *TempArray, int Left, int Right ){

	int Center;

	if( Left < Right ){

		Center = ( Left + Right ) / 2;
		Msort( Array, TempArray, Left, Center );
		Msort( Array, TempArray, Center+1, Right );
		Merge( Array, TempArray, Left, Center+1, Right );
	}
}

void MergeSort( ElementType *Array, int n ){

	ElementType *TempArray;

	TempArray = ( ElementType * )malloc( n * sizeof( ElementType ) );
	if( TempArray != NULL ){

		Msort( Array, TempArray, 0, n-1 );
		free( TempArray );
	}

	else
		printf("No Space For Temp Array!!!\n");
}


/* ========================================= */
/* Quick Sort;
/* Partition: Median-of-Three Partitioning
/* ========================================= */

ElementType Median_Three( ElementType *Array, int Left, int Right ){

	int Center = ( Left + Right ) / 2;

	if( Array[Left] > Array[Center] )
		Swap( &Array[Left], &Array[Center] );
	if( Array[Left] > Array[Right] )
		Swap( &Array[Left], &Array[Right] );
	if( Array[Center] > Array[Right] )
		Swap( &Array[Center], &Array[Right] );

	Swap( &Array[Center], &Array[Right-1] );

	return Array[Right-1];
}

#define Cutoff ( 3 )

void Qsort( ElementType *Array, int Left, int Right ){

	int i,j;
	ElementType Pivot;

	if( Left + Cutoff <= Right ){

		Pivot = Median_Three( Array, Left, Right );
		i = Left; j = Right - 1;
		for( ; ; ){

			while( Array[++i] < Pivot );
			while( Array[--j] > Pivot );

			if( i < j )
				Swap( &Array[i], &Array[j] );
			else
				break;
		}

		Swap( &Array[i], &Array[Right-1] );

		Qsort( Array, Left, i-1 );
		Qsort( Array, i + 1, Right );
	}

	else
		InsertionSort( Array+Left, Right-Left+1 );
}

void QuickSort( ElementType *Array, int n ){

	Qsort( Array, 0, n-1 );
}

/* ================================================ */
/*                     END  !                       */