数据结构几种常见的排序算法解析及其C语言实现

排序的定义
将给定若干数据元素根据指定数据项排列成一个有序序列的过程称为排序。
内排序
待排序数据一次性读入内存并完成排序的过程，称为内排序。
外排序
待排序数据分多次读入内存并完成排序的过程，称为外排序。

数据元素的顺序存储实现

typedef struct entry{        //数据元素
	KeyType key;				//排序关键字，KeyType应为可比较类型
	DataType data;				//data保护数据元素中的其他数据项
}Entry;
typedef struct list{       //顺序表
	int n;                //待排序数据元素量
	Entry D[MaxSize];  //静态数组存储元素
}List;   

简单选择排序算法
该算法的核心思想是：每一趟排序，找到待排序序列中关键字最小的数据元素，将其与待排序序列中第一个数据元素交换位置，并将其从下一趟待排序序列中移出，重复该过程，直到某趟排序序列时待排序序列中仅剩下两个数据元素。

int FindMin(List list,int startIndex){
	int i,minIndex=startIndex;
	for(i=startIndex+1;i<list.n;i++){
		if(list.D[i].key<list.D[minIndex].key)
		minIndex=i;
	}
	return minIndex;
}
void Swap(Entry *D,int i,int j){//交换顺序表中两个元素的位置
	Entry temp;
	if(i==j){
	return;
	}
	temp=*(D+i);
	*(D+i)=*(D+j);
	*(D+j)=temp;
}
void SelectSort(List *list){
	int minIndex,startIndex=0;
	while(startIndex<list->n-1){
		minIndex=FindMin(*list,startIndex);
		Swap(list->D,startIndex,minIndex);
		startIndex++;
	}
}

直接插入排序算法
该排序算法的核心是：从一个只包含一个元素的有序序列开始，不断地将待排序数据元素有序地插入这个有序序列中，直到有序序列包含了所有待排序数据元素为止。

void InsertSort(List *list){
	int i,j;
	Entry insertItem;
	for(i=1;i<list->n;i++){
		insertItem=list->D[i];
		for(j=i-1;j>=0;j--){
			if(insertItem.key<list->D[j].key)
			{
				list->D[j+1]=list->D[j];
			}
			else break;
		}
		list->D[j+1]=list->D[j];
	}
}

冒泡排序
核心思想是：从前向后不断交换相邻逆序的数据元素，重复该过程，直到任意相邻元素不再逆序排列为止。

typedef int BOOL;
void BubbleSort(List *list)
{
	int i,j;//i指每趟排序范围最后一个元素的下标
	for(i=list->n-1;i>0;i--)
	{
			BOOL isSwap=FALSE;
			for(j=0;j<i;j++)
			{
				if(list->D[j].key>list->D[j+1].key)
				{
					Swap(list->D,j,j+1);
					isSwap=TRUE;
				}
			}
			if(!isSwap) break;
	}
}

快速排序算法
该算法的核心思想是：
(1)在待排序序列中选择一个分割元素，将待排序序列中所有比分割元素关键字小或者相等的元素移动到左侧位置，将待排序序列中所有比分割元素关键字大或者相等的元素移动到分割元素右侧位置；
(2)然后将分割元素左侧所有元素都看作是一个待排序子序列，重复上述过程，直到这些元素完全有序；
(3)最后将分割元素右侧的所有元素都看作是一个待排序子序列，重复上述过程，直到这些元素完全有序。

//序列划分
int Patition(List *list,int low,int high){
		int i=low,j=high+1;
		Entry pivot=list->D[low];//pivot是分割元素
		do
		{
			do {
				i++;
			}while(i<high&&list->D[i].key<pivot.key);
			do{
				j--;
			}while(list->D[j].key>pivot.key);
			if(i<j)
			{
				Swap(list->D,i,j);
			}
		}while(i<j);
		Swap(list->D,low,j)
		return j;
}
//快速排序算法
void Quicksort(List *list,int low,int high)//递归函数
{
	int k;
	if(low<high)
	{
		k=Partition(list,low,high);
		QuickSort(list,low,high);
		QuickSort(list,k+1,high);
	}
}
void QuickSort(List *list)
{
	QuickSort(list,0,list->n-1);
}