几种排序的算法实现

存储结构

//存储结构
typedef struct 
{
	int key;
}RecordType;
typedef struct 
{
	RecordType R[MAXSIZE];
	int length;
}OrderList;

直接插入排序

/*length 存顺序表的长度，0用来当哨兵，存储要插入的数据，用来比较*/
//直接插入排序
void Straight_Insert_sort(OrderList* L)
{
	int i, j;
	for (i = 2; i <= L->length; i++)
	{
		L->R[0] = L->R[i];
		j = i - 1;
		while (L->R[0].key < L->R[j].key)
		{                                        
			L->R[j + 1] = L->R[j];			//如果要插入的数据比比较的数据小的话，就后移一位。
			j--;                                   //向前移动下标比较
		}/*while*/
		L->R[j+1] = L->R[0];       
	}/*for*/
}

希尔排序

基于插入排序的基础上进行了优化

//希尔排序
void ShellSort(OrderList *L)
{
	int i, j, d;
	RecordType tmp;   // 用来替换某个数据，以便交换
	for (d = L->length / 2; d > 0; d--)   //第一次间隔length/2
	{
		for (i = d + 1; i <= L->length; i++)
		{
			tmp = L->R[i];
			j = i - d;
			while (j >= 1 && tmp.key < L->R[j].key)
			{
				L->R[j+d] = L->R[j];
				j = j - d;
			}/*while j*/
			L->R[j + d] = tmp;
		}/*for  i*/

	}/*for  d*/
}

冒泡排序

相当于每次排序都找到当前无序区中最大的数据，使其向后移动

//冒泡排序

void BubbleSort(OrderList* L)
{
	int i, j;
	int flag = 0;
	for (i = 1; i <= L->length-1; i++)
	{
		//只在无序的数据区进行比较，length-i之后的已经是有序区了
		for (j = 1; j <= L->length - i; j++)
		{
			if (L->R[j].key> L->R[j+1].key)    //前后两个比较，如果前面的数据大，向后移动
			{
				RecordType tmp = L->R[j];
				L->R[j] = L->R[j+1];
				L->R[j+1] = tmp;
				flag = 1;//用来判断是否为有序表
			}/*if */
		}/*for j*/
		if(flag == 0)
		{
			break;  //如果第一次没有进行比较，说明表为有序表，不用继续比较了。
		}
	}/*for i*/
}

快速排序

//快速排序
//寻找一个枢纽，比枢纽小的，放在枢纽左边，比枢纽大的放在枢纽右边
//一趟快速排序
int Partition(OrderList* L, int i, int j)   /* /pɑːˈtɪʃ(ə)n/  隔板（国家的）分裂，分治；（数学）分割*/
{
	L->R[0] = L->R[i];
	int pivot = L->R[i].key;  //存枢纽的值,以便于进行比较
	/*先从后往前找比枢纽小的值，放到前端，再从前往后找比枢纽大的值，放到最后端，直到i<j*/
	while (i < j) 
	{
		while (i < j && L->R[j].key >= pivot)
		{
			--j;
		}/*while*/
		L->R[i] = L->R[j]; //将比枢纽的值小的那个数据换到最低端；
		/*从前往后找出枢纽大的，移动到后面*/
		while (i < j && L->R[i].key <=  pivot)
		{
			++i;
		}
		L->R[j] = L->R[i];
	}/*while  外循环*/
	/*一趟排序完成*/
	L->R[i] = L->R[0];
	return i;//返回枢纽目前的位置
}
/*快速排序的递归算法*/
void QuickSort(OrderList* L,int i,int j)
{
	int pivot; /*   /ˈpɪvət/ n. 支点，枢轴；最重要的人（或事物），核心；转动，旋转；策应位置；*/
	if (i < j)
	{
		pivot = Partition(L, i, j);
		QuickSort(L, i, pivot - 1);
		QuickSort(L, pivot + 1,j);
	}
}

简单选择排序

//简单选择排序
void easyChooseSort(OrderList* L)
{
	int i, j,min;
	RecordType tmp;
	for (i = 1; i <= L->length; i++)
	{
		min = i;
		for (j = i+1; j <= L->length; j++)
		{
			if (L->R[j].key < L->R[min].key)  //查询最小值
			{
				min = j;
			}
		}/*for */
		if (min != i)
		{
			tmp = L->R[i];
			L->R[i] = L->R[min];
			L->R[min] = tmp;
		}/*if */
	}/*for */

}

堆排序

//堆排序
/*筛选算法*/
void pileAdjust(OrderList* L, int s, int length)
{
	RecordType key;
	int j;
	key = L->R[s];
	for (j = 2 * s; j <= length; j=j*2)
	{
		if (j < length && L->R[j].key < L->R[j + 1].key)  //j < length 保证了右子树一定存在
		{
			j++;
		}
		if (key.key < L->R[j].key)   //如果比比较的数小，就换位置
		{
			L->R[s] = L->R[j];
			s = j;
		}
	}/*for j*/
	L->R[s] = key;
}

/*堆排序算法*/
void pileSort(OrderList* L)
{
	RecordType tmp;
	int i;
	/*进行第一次堆排序，建成小根堆*/
	for (i = L->length / 2; i > 0; i--)
	{
		pileAdjust(L, i, L->length);
	}/*for i */

	/*将根节点与尾部的结点换位置之后，再进行筛选*/
	for (i = L->length; i > 0; i--)
	{
		tmp = L->R[i];
		L->R[i] = L->R[1];
		L->R[1] = tmp;
		pileAdjust(L,1,i-1);
	}
}