排序及其算法

直接插入排序：

void InsertSort(SqList &L){
 	for(i = 2;i<=L.length;i++){//第一个元素在r[1]的位置，r[0]的位置为空的，留出来当哨兵用； 
 		if(L.r[i].key<=L.r[i-1].key){
 			L.r[0] = L.r[i];
			L.r[i] = L.r[i-1];//经过比较之后，将i-1移动到新插入位置i ，将i-1的位置空出来，方便接下来比较，若i-2大于哨兵则向后移动，若小与哨兵则把哨兵插入到此时位置j 
			for(j = i-2;L.r[0].key<L.r[j];j--){
				L.r[j+1] = L.r[j];
			}//off for
			L.r[j] = L.[0];  //由于从j=i-2的位置开始与哨兵作比较，所以大的会被放进j+1=i-1(在循环中j会减减1，i相对于也会） 
		 }//OFF if
	 }//off for

折半插入排序：

void BInsertSort(SqList &L){
	for(i = 2;i <= Llength;i++){
		L.r[0] = L.r[i];
		int low = 1,high = i-1;
		while(low<=high){
			middlle = (high + low)/2;
			if(L.r[0].key<L.r[middle].key){
				high = middle;
				high --;
			}//off if
			else{
				low = middle;
				low ++;
			}//off else
		}//off while
	}//off for 
    for(j = i-1;j<=middle;j++){
    	L.r[j+1] = L.r[j];
	} 
  L.r[middle] = L.r.[0];
} 

希尔排序：

//希尔排序
void ShellSort(int* arr, int n)
{
	int gap = n;
	while (gap>1)
	{
		//每次对gap折半操作
		gap = gap / 2;
		//单趟排序
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tem = arr[end + gap];
			while (end >= 0)
			{
				if (tem < arr[end])
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tem;
		}
	}
}

选择排序：

//选择排序
void swap(int* a, int* b)
{
	int tem = *a;
	*a = *b;
	*b = tem;
}
void SelectSort(int* arr, int n)
{
	//保存参与单趟排序的第一个数和最后一个数的下标
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		//保存最大值的下标
		int maxi = begin;
		//保存最小值的下标
		int mini = begin;
		//找出最大值和最小值的下标
		for (int i = begin; i <= end; ++i)
		{
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
		}
		//最小值放在序列开头
		swap(&arr[mini], &arr[begin]);
		//防止最大的数在begin位置被换走
		if (begin == maxi)
		{
			maxi = mini;
		}
		//最大值放在序列结尾
		swap(&arr[maxi], &arr[end]);
		++begin;
		--end;
	}
}

冒泡排序：

//冒泡排序
void BubbleSort(int* arr, int n)
{
	int end = n;
	while (end)
	{
		int flag = 0;
		for (int i = 1; i < end; ++i)
		{
			if (arr[i - 1] > arr[i])
			{
				int tem = arr[i];
				arr[i] = arr[i - 1];
				arr[i - 1] = tem;
				flag = 1;
			}
		}
		if (flag == 0)
		{
			break;
		}
		--end;
	}
}

堆排序：

//快速排序   hoare版本(左右指针法)
void QuickSort(int* arr, int begin, int end)
{
	//只有一个数或区间不存在
	if (begin >= end)
		return;
	int left = begin;
	int right = end;
	//选左边为key
	int keyi = begin;
	while (begin < end)
	{
		//右边选小   等号防止和key值相等    防止顺序begin和end越界
		while (arr[end] >= arr[keyi] && begin < end)
		{
			--end;
		}
		//左边选大
		while (arr[begin] <= arr[keyi] && begin < end)
		{
			++begin;
		}
		//小的换到右边，大的换到左边
		swap(&arr[begin], &arr[end]);
	}
	swap(&arr[keyi], &arr[end]);
	keyi = end;
	//[left,keyi-1]keyi[keyi+1,right]
	QuickSort(arr, left, keyi - 1);
	QuickSort(arr,keyi + 1,right);
}