排序算法

基本方法

插入排序，交换排序，选择排序，归并排序。

• 插入排序
  1、直接插入排序
  1)基本思想：将待排序的数组看成两部分，整个排序过程就是把右方的元素逐个插入到左边的区域中，构成新的有序区。
  2)插入一个元素示例：

 temp=A[i];
 j=i-1;
 while(A[j].key>temp.key && j>=1)
 { A[j+1]=A[j]; j=j-1;}
 A[j+1]=temp;

3)对整个表进行排序即为：

for(int i=2;i<=n;i++)
{/*将第0个位置元素空出来*/
	int t = a[i];
	j= j-1;
	while(a[j] > t && j >= 1)
	{
		a[j+1] = a[j];
		j--;
	}		
	a[j+1] = t;
}

2. 希尔排序
   1)基本思想：将待排序数组分为多组，在每组内进行直接插入排序，最后对整个序列进行直接插入排序。
   2)分组方法：给定一个步长d（d>0）对相隔为d的元素分为一组，在组内进行直接插入排序，d的取值为d1 = n / 2, d2 = d1 / 2, d3 = d2 / 2…

int d = n / 2;
	while (d > 0)
	{
		for (int i = d + 1; i <= n; i++)
		{
			int t = a[i];
			int j = t - d;
			while (a[j] > t&&j > 0)
			{
				a[j + d] = a[j];
				j = j - d;
			}
			a[j + d] = t;
		}
		d = d / 2;
	}

• 选择排序

1. 冒泡排序
   1)基本思想：从一段开始，逐个比较相邻的两个元素，发现倒序即交换。
   

int i = 0;
	bool exchanged;
	do
	{
		exchanged = false;
		for (int j = n - 1; j >= i; j++)
		{
			if (a[j] > a[j - 1])
			{
				int t = a[j];
				a[j] = a[j - 1];
				a[j - 1] = t;
				exchanged = true;
			}
			i++;
		}
	} while (i <= n - 1 && exchanged == true);

2. 快速排序
   1)基本思想：将数据划分为两部分，左边所有元素都小于右边所有元素，然后对左右两边进行排序。
   2)划分思想：选一个参考点作为中间元素（第一个元素即可），所有元素与之比较，大的放在右边，小的放在左边。
   3)具体划分方法：对a[s…t]进行划分, i=s,j=t
   （1）选择一个元素作为中间元素（例如 a[s]）;
   （2）首先将选择的中间元素保存 ，x = a[s];
   （3）首先从j所指的元素始向前搜索小于x的元素，搜索到后将a[j]放在a[i]处；
   （4）再从a[i]的位置开始向后搜索大于x的元素，将a[i移动到a[j]的位置；
   （5）重复（3）（4）直到i,j相等为止，再分别对两个子序列进行快排，直至每个子序列只含一个元素为止。
   

void partition(int a[], int s, int t, int& cutpoint)
{/*字表内排序*/
	int i = s, j = t;
	int x = a[s];
	while (i != j)
	{
		while (i<j&&a[j]>x)
		{
			j--;
		}
		if (i < j)
		{
			a[i] = a[j];
			i++;
		}
		while (i<j&&a[i]<x)
		{
			i++;
		}
		if (i < j)
		{
			a[j] = a[i];
			j--;
		}
	}
	a[i] = x;
	cutpoint = i;
}

void quick_sort(int a[], int s, int t)
{
	int i;
	if (s < t)
	{
		partition(a, s, t, i);
		quick_sort(a, s, i - 1);
		quick_sort(a, i + 1, t);
	}
}

• 选择排序

1. 直接选择排序
   1)基本思想：在待排序子表中找出最大（小）元素，并将该元素与子表的最前（后）面的元素进行交换。
   

void select_sort(int n, int a[])
{
	for (int i = 0; i < n; i++)
	{
		int min = i;
		for (int j = i + 1; j < n; j++)
		{
			if (a[min] > a[j])
				min = j;
		}
		if (min != i)
		{
			int t = a[min];
			a[min] = a[i];
			a[i] = a[min];
		}
	}
}

2. 堆排序
   1）基本思想(约定进行增排序，因而采用大根堆):
   首先要明确，堆排序是对一个数组的操作，而用完全二叉树只是一种形象的表述。
   如果初始序列是堆，则可通过反复执行如下操作而最终得到一个有序序列：
   输出根：即将根（第一个元素）与当前子序列中的最后一个元素交换。
   调整堆：将输出根之后的子序列调整为堆。
   如果初始序列不是堆，则首先要将其先建成堆，然后再按上述方式来实现。
   2）实现堆排序需要解决两个问题：
   （1）如何由一个无序序列建成一个堆？
   （2）如何在输出堆顶元素之后，调整剩余元素成为一个新的堆？
   问题（1）的解决方法是：
   从第n/2个元素开始，至第1个元素止，进行反复“筛选”
   问题（2）的解决方法是：
   在输出堆顶元素之后，以堆中最后一个元素替代之，此时根结点的左、右子树 均为堆，则仅需自上至下进行调整即可。
   我们称自堆顶至叶子的调整过程为“筛选”。

void sift(int a[], int k, int m)
{/*筛选算法
k表示以k为根的子树，其中最大元素的下标为m*/
	int x = a[k];
	bool finished = false;
	int i = k, j = i * 2;//i指示空位，j先指向左孩子结点
	while (j <= m && !finished)
	{
		if (a[j] < a[j + 1])
			j++;//让j指向左右孩子中的最大者
		if (a[j] > x)
		{
			a[j] = x;    //大的孩子结点值上移
			i = j;
			j = j * 2;//继续往下筛选      
		}
		else
			finished = true;
	}
	a[i] = x;//将原根值填充到所搜索到的当前空位置中
}

void heap_sort(int a[], int n)
{
	for (int i = n / 2; i >= 1; i--)
		sift(a, i, n);
	for (int i = n; i >= 2; i++)
	{
		int t = a[1];
		a[1] = a[i];
		a[i] = t;
		sift(a, 1, i - 1);
	}
}

• 归并排序
  1）归并思想：将两个或两个以上的有序表合并成一个新的有序表。
  2）利用归并的思想进行排序：
  首先将整个表看成是n个有序子表，每个子表的长度为1；
  然后两两归并，得到n/2个长度为2的有序子表；
  然后再两两归并,直至得到一个长度为n的有序表为止。
  

void merge(int a[], int c[], int u, int v, int t)
{//将两个有序表A[u]~A[v]和A[v+1]~A[t]归并到有序表C[u]~C[t]中
	int i, j, k;
	for (i = u, j = v + 1, k = u; i <= v && j <= t; k++)
	{
		if (a[i] < a[j])
		{
			c[k] = a[i];
			i++;
		}
		else
			c[k] = a[j];
		j++;
	}
	while (i <= v)
	{
		c[k] = a[i];
		i++;
		k++;
	}
	while (j <= t)
	{
		c[k] = a[j];
		j++;
		k++;
	}
}

void mergepass(int a[], int c[], int n, int len)
{//把数组A中的每一个长度为len的有序子表归并到数组C中
	int p, i;
	for (p = 0; p + 2 * len - 1 < n; p = p + 2 * len)//归并长度为len等长有序表
	{
		merge(a, c, p, p + len - 1, p + 2 * len - 1);
	}
	if (p + len < n)//归并剩余的两个不等长的有序表
		merge(a, c, p, p + len - 1, n - 1);
	else//只剩单个有序子表，直接放到数组C中
		for (i = p; i < n; i++)
			c[i] = a[i];
}

const int N = 10;
void mergesort(int a[], int n)
{
	int c[N]; 
	int len = 1;
	while (len < n)
	{
		mergepass(a,c, n, len);
		len = len * 2;
		mergepass(c,a, n, len);
		len = len * 2;
	}
}