部分排序算法总结（C++版）

1.直接插入排序

//第一个参数：数组
//第二个参数：数组最后一个元素的下标，数组的长度-1 
//要求：排序的数组是int型，下标为0的那个不存值不参与排序
void insertSort(int r[], int n)
{
	int j = -1;
	
	for(int i = 2; i <= n; i++)
	{
		r[0] = r[i];
		for(j = i - 1; j >= 1 && r[0] < r[j]; j--)
		{
			r[j+1] = r[j];
		}
		r[j+1] = r[0];
	}
	
}

2.堆排序

//堆调整算法
//供堆排序算法调用
void sift(int r[], int k, int m)
{
	int i = k;
	int j = 2 * i;
	int temp = 0;

	while (j <= m)
	{
		if (j < m && r[j] < r[j + 1])
		{
			j++;
		}
		if (r[i] > r[j])
		{
			break;
		}
		else
		{
			temp = r[j];
			r[j] = r[i];
			r[i] = temp;

			i = j;
			j = 2 * i;
		}
	}
}

//堆排序算法
//第一个参数：要排序 数组
//第二个参数：记录关键码的个数不是数组的长度 
void headSort(int r[], int n)
{
	int temp = 0;

	for (int i = n / 2; i >= 1; i--)
	{
		sift(r, i, n);
	}
	for (int i = 1; i < n; i++)
	{
		temp = r[n - i + 1];
		r[n - i + 1] = r[1];
		r[1] = temp;
		sift(r, 1, n - i);
	}
}

3.二路归并排序非递归算法

/*
一次归并算法
s是第一个序列的开头的下标
m是第一个序列的最后一个的下标
t是第二个序列的最后一个的下标
*/
void merge(int r[], int r1[], int s, int m, int t)
{
	int i = s;
	int j = m + 1;
	int k = s;

	while (i <= m && j <= t)
	{
		if (r[i] <= r[j])
		{
			r1[k] = r[i];
			i++;
			k++;
		}
		else //r[i] > r[j]
		{
			r1[k] = r[j];
			j++;
			k++;
		}
	}

	while (i <= m) //第二个序列提前结束，第一个没处理完
	{
		r1[k] = r[i];
		i++;
		k++;
	}

	while (j <= t) //第二个没处理完
	{
		r1[k] = r[j];
		j++;
		k++;
	}
}

void mergePass(int r[], int r1[], int n, int h) //一趟归并 
{
	int i = 1;
	
	while(i <= n - 2*h + 1)
	{
		merge(r, r1, i, i+h-1, i+2*h-1);
		i = i + 2*h;
	}
	
	if(i < n - h + 1)
	{
		merge(r, r1, i, i+h-1, n);
	}
	else
	{
		for(int k = i; k <= n; k++)
		{
			r1[k] = r[k];
		}
	}
}

/*
二路归并排序，
n是元素的个数，不是数组的长度，下标为0的单元不存值
*/
void mergeSort(int r[], int r1[], int n) 
{
	int h = 1;
	while(h < n)
	{
		mergePass(r, r1, n, h);
		h = 2 * h;
		
		mergePass(r1, r, n, h);
		h = 2 * h;
	}
}

4.简单选择排序算法

/*
第一个参数：要排序的数据
第二个参数：数组长度
*/
void sort(int r[], int n)
{
	int min = 0; //记录每趟比较时的最小下标
	int temp = 0; //临时变量

	for (int i = 0; i <= n - 2; i++)
	{
		min = i;
		for (int j = i + 1; j <= n - 1; j++)
		{
			if (r[j] < r[min])
			{
				min = j;
			}
		}

		if (r[i] != r[min]) //如果不相等 交换
		{
			temp = r[min];
			r[min] = r[i];
			r[i] = temp;
		}
	}
}

5.快速排序算法

/*
快速排序算法
第一个参数：要排序的数组
第二个参数：数组开始的下标
第三个参数：数组结束的下标
*/
void qulickSort(int r[], int first, int end)
{
	int pivot = 0;

	if (first < end)
	{
		pivot = partition(r, first, end); //一次划分
		qulickSort(r, first, pivot - 1); //递归对左子序列进行快速排序
		qulickSort(r, pivot + 1, end);
	}
}

/*
一次划分算法，供快速排序算法调用
*/
int partition(int r[], int first, int end)
{
	int i = first;
	int j = end;
	int temp = 0;

	while (i < j)
	{
		//右侧扫描
		while (i < j && r[i] <= r[j])
		{
			j--;
		}
		if (i < j)
		{
			temp = r[j];
			r[j] = r[i];
			r[i] = temp;
			i++; //交换前刚比较过，所以不用再比较，不写也可以但会多比较一次，
		}

		//左侧扫描
		while (i < j && r[i] <= r[j])
		{
			i++;
		}
		if (i < j)
		{
			temp = r[j];
			r[j] = r[i];
			r[i] = temp;
			j--;
		}
	}
	return i;
}

6.起泡排序算法

/*
起泡排序算法
第一个参数：要排序的数组（下标为0的元素不参与排序）
第二个参数：数组的最后一个下标
*/
void bubbleSort(int r[], int n)
{
	int temp = 0;
	int bound = 0;
	int exchange = n;
	
	while (exchange)
	{
		bound = exchange;
		exchange = 0;
		for (int j = 1; j <= bound - 1; j++)
		{
			if (r[j] > r[j + 1])
			{
				temp = r[j + 1];
				r[j + 1] = r[j];
				r[j] = temp;
				exchange = j;
			}
		}
	}
}

7.希尔排序算法

/*
希尔排序算法
第一个参数：要排序的数组（下标为0的元素不参与排序）
第二个参数：数组的最后一个下标
要求：排序的数组是int型，下标为0的那个不存值不参与排序
*/
void shellSort(int r[], int n)
{
	int d = -1;
	int i = -1;
	int j = -1;
	
	for(d = n / 2; d >= 1; d = d / 2)
	{
		for(i = d + 1; i <= n; i++)
		{
			r[0] = r[i];
			for(j = i - d; j > 0 && r[0] < r[j]; j = j - d)
			{
				r[j+d] = r[j];
			}
			r[j+d] = r[0];
		}
	}
}