排序问题——插入排序&&交换排序（直接&折半&希尔&冒泡&快排）

排序——插入排序&&交换排序（直接&折半&希尔&冒泡&快排）

【1】插入排序

• 直接插入排序：顺序法定位插入位置
• 二分插入排序：二分法定位插入位置
• 希尔排序——缩小增量，多遍插入排序

一、直接插入法（使用哨兵）

1、复制为哨兵：将待插入元素复制到数组下标为0的位置上
2、记录后移，查找插入位置
3、插入到正确位置

L.[0]=L.r[i];  //i位置上为待插入的数
for（j=i-1;L.r[0].key<L.r[j[.key;j--)
    L.r[j+1]=L.r[j];
L[j+1]=L.r[0];
    

直接插入排序算法*（使用哨兵算法）*

void insertSort(SqList &L){
  int i ,j;     //无序列表中插入元素下标i
  for(i=2;i<=L.length;++i)     //从第二个元素开始
     if(L.r[i].key<L.r[i-1].key)     //是否已经比前一个元素大了
     {
         L.r[0]=L.r[i];         //复制为哨兵
         for(j=i-1;L.r[0].key<L.r[j].key;--j)
         {
           L.[j+1]=L.r[j];        //记录后移
           }
         L.r[j+1]=L.r[0];       //插入到正确位置
    }
  }

效率分析：
（1）比较序列中两个关键字的大小
（2) 移动记录
最佳的情况（关键字在记录序列中顺序有序）
{ 11，25，32，47，56，70，81，85，92，96}
比较次数 n-1次
移动次数 0 次

最坏的情况（关键字在记录序列中逆序有序）
{85，92，62，70，56，47，33，25，11}
比较次数（n+2）（n-1）/ 2 次
移动次数 （n+4）（n-1）/ 2 次

小结：
原始数据越接近有序，排序速度越快
要提高查找速度：

• 减少元素的比较次数
• 减少元素的移动次数

二、折半插入排序

void BinsertSort(Sqlist &L)
{
	for(i=2;i<=L.length;++i)
		L.[0]=L.r[i];
	low=1;
	high=i-1;
	while(low<=high)
	{
		if（L.r[0].key<L.r[mid].key)
			high=mid-1;
		else 
			low=mid+1;
	}
	for(j=i-1;j>=high+1;--j)
	{
		L.r[j+1]=L.r[j];
	}
}

小结

• 折半查找比顺序查找快，所以折半插入排序的平均性能来说比直接插入排序要快；
• 他需要的关键码比较次数与待排序对象序列的初始排列无关，仅仅依赖于对象个数，在插入第i个对象时，需要经过log2i+1次关键码比较，才能确定他的位置。
• 移动次数上，取决于初始排列，直接插入排序于折半插入排序的对象移动次数相同。
• 减少了比较次数，但没有减少移动次数
  平均性能优于直接插入排序

三、希尔排序

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

希尔排序算法特点

• 缩小增量
• 多遍插入排序

{81，94，11，96，12，35，17，95，28，58，41，75，15}
选择增量为5为间隔，得
{81，94，11，96，12}
{35，17，95，28，58}
{41，75，15}
元素个数减少，
81，35，41来排序，使之快速移动一大步
{35，94，11，96，12}
{41，17，95，28，58}
{81，75，15}
接下来时94，17，75进行排序
多次排序后，排序完成，变为
{35，17，11，28，12，41，75，15，96，58，81，94，95}
快速接近了最终的位置，使数据元素大大的接近最终的位置。

接下来进行间隔为3，再进行插入排序。
插入完成后，得到
{28，12，11，35，15，41，58，17，94，75，81，96，95}

最终进行一次间隔为1的排序，即直接插入排序
大大减少了移动次数，得到最终序列为
{11，12，15，17，28，35，41，58，75，81，94，95，96}

方法：

• 定义增量序列，一次比一次小
• 对每个增量进行插入排序，逐渐递减

特点：

• 一次移动，移动位置比较大，跳跃式接近排序后的最终位置
• 最后一次只需要少量移动
• 增量序列必须是递减的，最后一个必须时1
• 增量序列应该互为质数

void ShellSort(Sqlist &L,int dlta[],int t)
{
	for(k=0;k<t;++k)
		ShellSort(L，dlta[k]);
}

//dlta[]为增量序列，dk的值依次存放在数组中

**加粗样式**

其中一趟的排序操作

void ShellSort(Sqlist &L,int dk)
{
//dk为步长因子，后续进入插入排序
	for(i=dk+1;i<=L.length;++i)
		if(r[i].key<r[i-dk].key)
		{
			r[0]=r[i];
		for(j=i-dk;j>0&&(r[0].key<r[j].key);j=j-dk)
			r[j+dk]=r[j];
		r[j+dk]=r[0];
		}//进行交换，用哨兵
}

希尔排序算法分析

• 算法效率与 增量序列的取值有关
• 希尔排序是一种不稳定的排序算法
• 比如有相同数据存在时，数据的相对位置可能发生改变，他就是不稳定的。
• 不足之处：不适合在链式存储结构上实现

【2】交换排序

• 冒泡排序 O（n平方）
• 快速排序 O（n*log以二为底的n）
  精髓：两两比较，如果发生逆序，则交换，直到所有记录都排好序为止。

1、冒泡排序

基本思想：每趟不断将记录两辆比较，”前小后大“规则交换（升序）
记忆方法：大数沉底

void BubbleSort(Sqlist &L)
{
	int m,i,j;
	RedType temp;
	for(m=1;m<=n-1;m++)  //总共需要m趟 n总共多少数参与排序
	{
		for(j=1;j<=n-m;j++)
		{
			if(L.r[j].key>L.r[j+1].key)
				{
				 temp=L.r[j].key;
				 L.r[j].key=L.r[j+1].key;
				 L.r[j+1].key=temp;
				 } //endif
		} //for
	} //for
}

优化：一旦某一趟比较时不出现记录交换，说明已排好序了，就可以结束本算法。

void BubbleSort(Sqlist &L)
{
	int m,i,j;
	int flag=1;
	RedType temp;
	for(m=1;m<=n-1&&flag==1;m++)  //总共需要m趟 n总共多少数参与排序
	{
		flag=0;
		for(j=1;j<=n-m;j++)
		{
			if(L.r[j].key>L.r[j+1].key)
				{
				flag=1;  //已经发生交换，则置为1
				 temp=L.r[j].key;
				 L.r[j].key=L.r[j+1].key;
				 L.r[j+1].key=temp;
				 } //endif
		} //for
	} //for
}

冒泡算法性能分析

1、快速排序

基本思想：

1. 任取一个元素为中心（枢轴）
2. 所有比它小的元素一律前方，比它大的元素一律后方，形成左右两个子表
3. 对子表重新选择中心元素并用此规则调整
4. 直到每个子表的元素只剩一个
   （递归思想）

快排特征：

1.每一趟的子表的形成是采用两头向中间交替式逼近（low=high）
2. 由于每趟对各子表的操作都相似，可以采用递归算法

Void main(){
	Qsort(L,1,L.length);
	}
void Qsort(Sqlist &L,int low , int high)
{
	if(low<high)
	{
		pivotloc=partition(L,low,high);
		Qsort(L,low,pivotloc-1); //pivotloc中心点为止
		Qsort(L,pivotloc+1,high);
	} //endif
}

int Patition(Sqlist &L,int low , int high)
{
	L.r[0]=L.r[low];
	pivotkey=L.[low].key;
	while(low<high)
	{
		while(low<high&&L.r[high].key>pivotkey)
			--high;
		L.r[low]=L.r[high];
		while(low<high&&L.r[high].key>pivotkey)
			++low;  //右边大，则不移动high，low++，继续循环判断下一个low位置上的数与此时的high比较
		L.r[high]=L.r[low];
	}  //反复搬运左右两边，交替搬运 
	L.r[low]=L.r[0];
	return low;
}

小结：

• 快速排序不是原地排序，由于程序中使用了递推。需要递归调用栈的支持，而栈的长度取决于递归调用的深度，即使不使用递归，也需要用用户栈。
• 平均情况下，需要O（logn）的栈空间
• 最坏情况，栈空间达到O（n)
• 快排是不稳定的

性能

1. 快速排序不适合对于原本有序或者基本有序的记录序列进行排序。
2. 划分元素的选取，是影响时间性能的关键
3. 输入数据次序越乱，划分元素值的随机性越好，排序速度越快，快速排序不是自然排序方法。