第11章 排序

     1. 插入排序----逐步优化提升其性能

//循环中使用变量j跟踪被筛选的元素，只要该元素没有前驱(即j>0)且没有到达最终位置(即该元素小于它的前驱)
//则循环就交换该元素和它的前驱
void InsertSort1(int * pArry, int len)
{
	int i, j;
	for (i = 1; i < len; i++)
	{
		for (j = i; j > 0 && pArry[j - 1] > pArry[j]; j--)
		{
			swap(pArry[j - 1], pArry[j]);
		}
	}
}


/*可以讲swap()函数的函数体写成内联嵌入到内循环中实现加速*/
void InsertSort2(int * pArry, int len)
{
	int i, j;
	int temp;
	for (i = 1; i < len; i++)
	{
		for (j = i; j > 0 && pArry[j - 1] > pArry[j]; j--)
		{
			temp = pArry[j];
			pArry[j] = pArry[j - 1];
			pArry[j - 1] = temp;
		}
	}
}

//InsertSort2()内循环中总是给temp变量赋相同的值，将上面两个含t的赋值语句移处内循环，
//并相应的修改比较语句
void InsertSort3(int * pArry, int len)
{
	int i, j;
	int temp;
	for (i = 1; i < len; i++)
	{
		temp = pArry[i];
		for (j = i; j > 0 && pArry[j - 1] > temp; j--)
		{
			pArry[j] = pArry[j - 1];
		}
		pArry[j] = temp;
	}
}

     2. 快速排序

//改进后的快速排序算法(单向划分)
//算法思想：将待排序序列的第一个元素作为参照值，排列序列使得所有小于参照值的元素在m的一端，
//         所有大于参照值的元素在m的另一端,循环终止后交换参照值与位置m对应的元素
void QSort1(int * pArry, int low, int high)
{
	if (low >= high)
	{
		return;
	}
	int m = low;
	for (int i = low + 1; i <= high; i++)
	{
		if (pArry[i] < pArry[low])
		{
			swap(pArry[++m], pArry[i]);
		}
	}
	swap(pArry[low], pArry[m]);

	QSort1(pArry, low, m - 1);
	QSort1(pArry,  m + 1, high);
}

//改进后的快速排序算法(双向划分)
//算法思想：主循环中有两个内循环，第一个内循环将j向左移，直到遇到小于参照值时停止；
//         第二个内循环将i向右移，直到遇到大于参照值时停止，然后主循环内测试这两个下标是否交叉
//         并交换他们的值。循环结束后，交换参照值元素和指针j指针的元素
void QSort2(int * pArry, int ileft, int iright)  
{  
	int i = ileft;  //指向待排序序列的最左端  
	int j = iright; //指向待排序序列的最右端  
	if (i >= j)
	{
		return;
	}

	while (i < j)  
	{  
		while (i < j && pArry[j] >= pArry[ileft])  //从右边扫描找到比第一个元素小的元素   
		{                                  
			--j;                             
		}                                   
		while ( i < j && pArry[i] <= pArry[ileft]) //从左边扫描找到比第一个元素大的元素   
		{  
			i++;  
		} 
		if (i > j)  //判断指针
		{
			break;
		}
		swap(pArry[i], pArry[j]); //交换两个元素,将该处展开还可以提升性能
	}
	swap(pArry[j], pArry[ileft]); //循环结束后，交换第一个元素和指针j指针的元素(这里不能是i，因为j指向的元素比第一个元素小)        

	QSort2(pArry, ileft, j - 1);    //递归对左子序列进行快排  
	QSort2(pArry, j + 1, iright);   //递归对右子序列进行快排  
} 

     C库函数qsort非常简单且相对较快，但比自己写的快速排序慢，因为其通用而灵活的接口对每次比较都使用函数调用。

习题2：把x[l]用作哨兵以加速Lomuto的划分方案。说明如何利用该方法来移除循环后面的swap。

//从右向左扫描，可移除循环后面的swap
void QSort1_v2(int * pArry, int low, int high)
{
	if (low >= high)
	{
		return;
	}
	int m = high + 1;
	for (int i = high; i >= low; i--)
	{
		if (pArry[i] >= pArry[low])
		{
			swap(pArry[--m], pArry[i]);
		}
	}

	QSort1_v2(pArry, low, m - 1);
	QSort1_v2(pArry,  m + 1, high);
}

习题3. 选择排序与希尔排序

//思想：首先将最小的值放在pArry[0]中，再将剩下的最小值放入x[1]中,依次类推
void SelectSort(int *pArry, int len)
{
	int i, j;
	for (i = 0; i < len; i++)
	{
		for (j = i + 1; j < len; j++)
		{
			if (pArry[j] < pArry[i])
			{
				swap(pArry[i], pArry[j]);
			}
		}
	}
}

//希尔排序(递减增量排序)
void ShellSort(int *pArry, int len)
{
	int i, j;
	for (int dk = len / 2; dk > 0; dk /= 2)  //排序趟数，dk为间隔距离
	{
		for (i = dk; i < len; i++)    //对子序列进行直接插入排序
		{
			for (j = i ; j >= dk && pArry[j] < pArry[j - dk]; j -= dk)
			{
				swap(pArry[j], pArry[j - dk]);
			}
		}
	}
}

习题14. 结合选择排序思想和递归思想，得到下面的排序算法

//结合选择排序和递归思想，每一次函数调用都在剩下待排序数组中排序出最小的元素
void QSort5(int * pArry, int n)
{
	int i;
	if (n <= 1)
	{
		return;
	}
	for (i = 1; i < n ; i++)
	{
		if (pArry[i] < pArry[0])
		{
			swap(pArry[i], pArry[0]);
		}
	}
	QSort5(pArry + 1, n - 1);  //指针后移，长度减1
}