别再说排序难了

目录

 

插入排序

1.直接插入排序

希尔排序

交换排序

1.冒泡排序

2.快速排序

选择排序 

1.简单选择排序

堆排序

---

插入排序

---

1.直接插入排序

基本思想：依次将待排序序列中的每一个记录插入到已排好序的序列中，直到全部记录都排好序，将无序区中的元素依次插入到有序区中

待排序记录序列 12 30 25 9 18

初始有序区        12 30 25 9 18

第1趟排序结果  12 30 25 9 18

第2趟排序结果  12 25 30 9 18

第3趟排序结果   9 12 25 30 18

第4趟排序结果   9 12 18 25 30

void Sort::InsertSort()
{
	for(int i = 1; i < length; i++) {
		for(int j = i - 1; j >= 0 && temp < data[j]; j--) {
			temp = data[j];
			data[j] = data[j+1];
			data[j+1] = temp;
		}
	}
}

---

希尔排序

基本思想：先将整个待排序记录序列分割成若干个子序列，在子序列内分别进行直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。

待排序记录序列 59 20 17 36 98 14 23 83 13 28

d=5第一趟排序 14 20 17 13 28 59 23 83 36 98

d=2第二趟排序 14 13 17 20 23 59 28 83 36 98

d=1第三趟排序 13 14 17 20 23 28 36 59 83 98

ShellSort()
{
	int d, i, j, temp;
	for (d = length / 2; d >= 1; d = d / 2)//增量为d进行直接插入排序
	{
		for (i = d; i < length; i++)//进行一趟希尔排序
		{
			temp = data[i];//暂存待插入记录
			for (j = i - d; j >= 0 && temp < data[i]; j = j - d)
				data[j + d] = data[j];//记录后移d个位置
			data[j + d] = temp;
		}
	}
}

交换排序

---

1.冒泡排序

基本思想：两两比较相邻记录，如果反序则交换，直到没有反序的记录为止

待排序记录序列 50 13 55 97 27 38 49 65

第一趟排序结果 13 50 55 27 38 49 65 97

第二趟排序结果 13 50 27 38 49 55 65 97

第三趟排序结果 13 27 38 49 50 55 65 97

第四趟排序结果 13 27 38 49 50 55 65 97

BubbleSort()
{
	int j, exchange, bound, temp;
	exchange = length - 1;	//第一趟冒泡排序的区间
	while (exchange != 0)
	{
		bound = exchange; exchange = 0;
		for (j = 0; j < bound; j++)		//一趟冒泡排序的区间是0~bound
		{
			if (data[j] > data[j + 1])
			{
				temp = data[j];
				data[j] = data[j + 1];
				data[j + 1] = temp;
				exchange = j;		//记载每一次记录交换的位置
			}
		}
	}
}

---

2.快速排序

基本思想：首先选定一个轴值，（pivot，即比较的基准），将待排序记录划分成两部分，左侧记录均小于轴值，右侧记录均大于轴值 

待排序记录序列 23 13 35 6 19 50 28

第一趟排序结果 19 13 6 23 35 50 28

第二趟排序结果 6 13 19 23 28 35 50

第三趟排序结果 6 13 19 23 28 35 50

第四趟排序结果 6 13 19 23 28 35 50

int Partition(int first, int last)
{
	int temp, i = first, j = last;
	while (i < j)
	{
		while (i < j && data[i] < data[j])j--;
		if (data[i] < data[j])
		{
			temp = data[i];
			data[i] = data[j];
			data[j] = temp;
			a++;
		}
		while (i < j && data[i] < data[j])i++;
		if (data[i] < data[j])
		{
			temp = data[i];
			data[i] = data[j];
			data[j] = temp;
			j--;
		}
	}
	return i;
}


QuickSort(int first,int last)
{
	if (first >= last) return;	//区间长度为1，递归结束
	else {
		int pivot = Partition(first, last);		//一次划分
		QuickSort(first, pivot - 1);			//对左侧子序列进行快速排序
		QuickSort(pivot + 1, last);				//对右侧子序列进行快速排序
	}
}

选择排序 

---

1.简单选择排序

待排序记录序列 38 27 50 13 45

第一趟排序结果 13 27 50 38 45

第二趟排序结果 13 27 50 38 45

第三趟排序结果 13 27 38 50 45

第四趟排序结果 13 27 38 45 50

SelectSort()
{
	int i, j, index, temp;
	for (i = 0; i < length - 1; i++)
	{
		index = i;
		for (j = i + 1; j < length; j++)
			if (data[j] < data[index])index = j;
		if (index != i)
			temp = data[i]; data[i] = data[index]; data[index] = temp;
	}
}

堆排序

Sift(int k, int last)
{
	in i, j, temp;
	i = k; j = 2 * i + 1;
	while (j <= last)
	{
		if (j < last && data[j] < data[j + 1])j++;
		if (data[i] > data[j])break;
		else {
			temp = data[i]; data[i] = data[j]; data[j] = temp;
			i = j; j = 2 * i + 1;
		}
	}
}

HeapSort()
{
	int i, temp;
	for (i = ceil(length / 2) - 1; i >= 0; i--)
		Sift(i, length - 1);
	for (i = 1; i < length, i++)
	{
		temp = data[0]; data[0] = data[length - i]; data[length - i] = temp;
		Sift(0, length - i - 1);
	}
}

归并排序