C语言实现各种排序

C语言实现各种排序

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

//********************************************************
//直接插入排序 （稳定）
//********************************************************
void StraightInsertionSort (int *arr,int arr_size){
	int i,j;
	for ( i = 1 ; i < arr_size ; i++ ) {
		int temp = arr[i];
		
		int j = i-1;
		while( (j >= 0) && (arr[j] > temp) ){
			arr[j+1] = arr[j];
			--j;
		}
		arr[j+1] = temp;
	}
	return;
}

//********************************************************
//简单选择排序-基于交换（不稳定）
//********************************************************
void SelectSort (int *arr,int arr_size){
	int i,j;
	for( i = 0 ; i < arr_size - 1 ; ++i){
		int min_index = i;
		for( j = i+1 ; j < arr_size ; ++j )
			if( arr[j] < arr[min_index] )
				min_index = j;

		int temp = arr[min_index];
		arr[min_index] = arr[i];
		arr[i] = temp;
	}
	return;
}

//********************************************************
//冒泡排序（稳定）
//********************************************************
void BubbleSort (int *arr,int arr_size){
	int i,j;
	for( i = 0 ; i < arr_size-1 ; ++i ){
		for( j = 0 ; j < arr_size-1-i ; ++j ){
			if( arr[j] > arr[j+1] ){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
	return; 
} 

//********************************************************
//希尔排序（不稳定）
//********************************************************
void ShellSort(int *arr, int length){
	int i,j,k,gap;	
	for( gap = length/2 ; gap > 0 ; gap = gap/2 ){
		for( i = 0 ; i < gap ; i++ ){
			for( j = i+gap ; j<length ; j=j+gap ){
				if( arr[j] < arr[j - gap] ){
					int temp = arr[j];
					k = j - gap;
					while( k >= 0 && arr[k] > temp ){
						arr[k + gap] = arr[k];
						k = k - gap;
					}
					arr[k + gap] = temp;
				}
			}
		}
	}
	return;
}

//********************************************************
//快速排序（不稳定）
//********************************************************
void QuickSortRecursion(int *arr,int left,int right){
	if(left <= right){
		int temp = arr[left];
		
		int i = left;
		int j = right;
		
		while( i < j ){
			while( i < j && arr[j] >= temp) --j;
			if( i < j ){
				arr[i] = arr[j];
				++i;
			}
			while( i < j && arr[i] <= temp) ++i;
			if( i < j ){
				arr[j] = arr[i];
				--j;
			}
		}
		arr[i] = temp;
		QuickSortRecursion( arr , left , i-1 );	
		QuickSortRecursion( arr , i+1 , right );	
	}
	return;
} 

void QuickSort(int *arr,int length){
	return QuickSortRecursion( arr , 0 , length-1 );
} 

//********************************************************
//堆排序-优先队列（不稳定）
//********************************************************
void HeapSortSift(int *arr,int low,int high){
	int i = low;
	int j = 2 * i + 1;
	int temp = arr[i];
	while( j <= high ){
		if(j<high && arr[j] < arr[j+1])
			++j;
		if( temp < arr[j] ){
			arr[i] = arr[j];
			i = j;
			j = (2 * i) + 1;
		}else{
			break;
		}
	}
	arr[i] = temp;
}

void HeapSort(int *arr,int length){
	int i;
	//生成大顶堆
	for( i = length/2-1 ; i>= 0 ; --i )	//最后一个非叶子节点到根节点
		HeapSortSift( arr , i , length-1 );
		
	//大顶堆->小顶堆
	for( i = length-1 ; i > 0 ; --i ){
		int temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;
		HeapSortSift( arr , 0 , i-1 );
	} 
	return;
}

//********************************************************
//归并排序-可实现数组子序列排序 （稳定）
//********************************************************
void Merge( int *arr , int left , int mid , int right ){
	int i,j,k;
	int n1 = mid - left + 1;
	int n2 = right - mid;
	int L[n1],R[n2];
	for ( i = 0 ; i < n1 ; ++i )
		L[i] = arr[left+i];
	for ( j = 0 ; j < n2 ; ++j)
		R[j] = arr[mid+j+1];
	
	i = 0;
	j = 0;
	k = left;
	while ( i < n1 && j < n2 ){
		if ( L[i] <= R[j] )
			arr[k++] = L[i++];
		else
			arr[k++] = R[j++];
	}
	
	while ( i < n1 )
		arr[k++] = L[i++];
	
	while ( j < n2 )
		arr[k++] = R[j++];
}

void MergeSort( int *arr , int left , int right ){
	if ( left < right ){
		int mid = (left+right)/2;
		MergeSort( arr , left , mid );
		MergeSort( arr , mid+1 , right );
		Merge( arr , left , mid , right );
	}
}
 

int main(){
	int i,num; 
	int arr[100000];
	num = 8000;
	
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	DWORD start_time = GetTickCount();
	StraightInsertionSort(arr,num);
	DWORD end_time = GetTickCount();
	printf("直接插入排序 （稳定）\t\t\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	start_time = GetTickCount();
	SelectSort(arr,num);
	end_time = GetTickCount();
	printf("简单选择排序-基于交换（不稳定）\t\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	start_time = GetTickCount();
	BubbleSort(arr,num);
	end_time = GetTickCount();
	printf("冒泡排序（稳定）\t\t\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	num = 80000;
		
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	start_time = GetTickCount();
	ShellSort(arr,num);
	end_time = GetTickCount();
	printf("希尔排序（不稳定）\t\t\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	start_time = GetTickCount();
	QuickSort(arr,num);
	end_time = GetTickCount();
	printf("快速排序（不稳定）\t\t\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	start_time = GetTickCount();
	HeapSort(arr,num);
	end_time = GetTickCount();
	printf("堆排序-优先队列（不稳定）\t\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	for( i = 0 ; i < num ; i++){
		arr[i] = rand()%num;	
	}
	start_time = GetTickCount();
	MergeSort(arr,0,num-1);
	end_time = GetTickCount();
	printf("归并排序-可实现数组子序列排序 （稳定）\t%d条\t= %d(ms)\n",num,(end_time - start_time));
	
	return 0;
}