基于复杂问题求解策略设计的排序算法

一：常见的复杂问题求解策略以及由其产生的算法和常见问题有：

递归与分治:大规模问题转换为小规模问题，最后要有一个边界。直接插入排序+归并排序+快速排序

动态规划：分阶段处理，多阶段决策。前面的阶段都对后面的阶段产生影响。

Floyd算法+冒泡排序

穷举（回溯+分支限界）：枚举所有的可能，在枚举过程中，根据verify判定是否在当前状态基础上继续枚举。

水仙花 N皇后 马踏棋盘

贪心思想：最小生成树，Huffman树，选择排序

逆向思维：Hash查找 基数排序

以退为进：堆排序

二：基于递归与分治设计的直接插入排序和归并排序

1、直接插入排序

1.1思路

根据递归与分治的思想，首先第一个首记录一定有序，然后从第二个到最后一个，每次都将当前记录插入到其前面有序表中，最终使所有记录有序。

1.2代码实现

比较待插入记录和他的前一个记录，如果大于等于前一个记录，则不用移动。否则，就备份带插入记录，将他前面的元素分别后移，直到备份记录大于他前面的记录为止。最后将备份记录填入即可。但这种表述存在一些问题，就是可能会出现越界的情况，为了避免这种情况的发生，我们引入了哨所的概念，即在存记录的时候浪费一个空间，将a[0]用于备份记录。这样就可以将上面的表述改成，比较待插入记录和他的前一个记录，如果大于等于前一个记录，则不用移动。否则，将待插入记录存入哨中，只要之前的元素大于哨中的元素就后移。最后将哨中记录填入即可。这样因为不用每次都判断是否越界，比较时用的时间（不是复杂度）相对少些。因为这个操作比较简单实用，下面只给出用哨进行插入排序的代码。

void InsertSort(int* a,int N)
{
for(int i=2;i<=N;i++)
{
if(a[i]<a[i-1])//比较
{

a[0]=a[i];//移动
int j;
for(j=i-1;a[j]>a[0];j--)
{          //比较
a[j+1]=a[j];//移动
}
a[j+1]=a[0];//移动
}
}
}

1.3复杂度分析

最好情况：待排序序列关键字非递减有序（正序）

“比较”的次数：n-1;“移动”的次数 0

最坏情况：待排序序列关键字非递增有序（逆序）

“比较”的次数：(n-1)(n+2)/2;“移动”的次数 (n+4)(n-1)/2

时间复杂度O(n^2),空间复杂度O(1)，稳定！！！

2、折半插入排序

2.1思路

因为插入排序有一个非常重要的操作，就是在前面有序的子序列找到第一个比带插入元素大的元素，所以我们可以用折半查找来定位，如此实现的插入排序我们便称为折半插入排序。

2.2代码实现

low=1，high=i-1，mid=(low+high)/2；与中间元素比较，如果中间元素大，则high=mid-1，fo否则，low=mid+1。重复上述操作，当low第一次大于high时，high右侧是第一个比带插入元素严格大的元素，插入元素为high+1(也就是low)。

void midInsertSort(int *a,int N)
{
for(int i=2;i<=N;i++)
{
a[0]=a[i];
int low=1,high=i-1;
while(low<=high)
{
int mid=(low+high)/2;
if(a[mid]>a[0]) high=mid-1;
else
low=mid+1;
}
for(int j=i-1;j>high;j--)
{
a[j+1]=a[j];
}
a[low]=a[0];
}
}

2.3复杂度分析

时间复杂度：O(n^2);空间复杂度：O(1);稳定！

3、希尔排序

3.1思路

首先根据希尔增量，将记录序列划分为d个子序列，分别对各个子序列进行直接插入排序，最后一趟d=1时对全部记录进行直接插入排序。又称缩小增量排序。（注：虽然这种排序算法也体现了以退为进的思想，但由于他调用了多次插入排序，故将他一并放入了这个模块里面）这个算法设计是由于充分洞察了直接插入排序的优点，即序列基本有序的时候直接插入排序很快，对更短的子序列进行排序是，插入排序也很快。这种算法就是将直接插入排序的优点发挥到最大，有效提升了排序的速度。

3.2代码实现

根据上面的思路跟容易给出希尔排序的代码，其中最主要的就是希尔增量的确定。使用不同的增量对希尔排序的时间复杂度的改进将不一样，甚至一点小的改变都将引起算法性能剧烈的改变。现在好像也没有确定的希尔增量选取的方法。可以看下下面链接所提供的论文：希尔排序最佳增量序列研究

https://wenku.baidu.com/view/0ffd354bcf84b9d528ea7ae3.html

下面的代码是根据k=N/2的增量序列给出的代码：

int* getDldt(int N,int* dldk,int & k)
{
k=0;
while(N!=0)
{
dldk[k++]=N/2;
N/=2;
}
return dldk;
}
void shellInsert(int* a,int dk,int N)
{
for(int i=dk+1;i<=N;i++)
{
if(a[i]<a[i-dk])
{
a[0]=a[i];
int j;
for(j=i-dk;j>0&&(a[0]<a[j]);j-=dk)
a[j+dk] = a[j];  //记录后移一增量
a[j+dk] = a[0];
}
}
}
void shellSort(int *a,int *dldk,int k,
4000
int N)
{
for(int i=0;i<k;i++)
shellInsert(a,dldk[i],N);
}

3.3复杂度分析

子序列排好序后大序列基本有序，此时直接插入插入排序效率高。此外，初始是对更短的子序列排序，插入排序的效率也很高。时间是d序列的函数，而d的确定尚待研究，最坏时间复杂度为O(n^2),实验最快会达到O(n^1.3)。是一个不稳定的排序算法。比如：11 23 12 9 18 16 25 36 30 47 30 第二趟希尔排序，增量设为3时后面的30会跑到前一个30的钱前面。

4、其他插入排序

2-路插入排序

表插入排序

呃…我也不会，只是看到鲁大师课件中给出了，就先列这里以后有时间再学习吧。

5、归并排序

5.1思路

递归与分治：递归边界：长度为一的自然有序，一分为二，分别排序，然后归并。

5.2代码实现

5.2.1用递归的思想进行实现，只要理清递归关系，写出一个归并函数进行递归即可。

void Merge(int R[],int low,int mid,int high,int T[])
{
int P_Left=low,P_Right=mid+1,P_Result=low;
while(P_Left<=mid&&P_Right<=high)
{
if(R[P_Left]<=R[P_Right])
{
T[P_Result]=R[P_Left];
P_Left++;P_Result++;
}
else
{
T[P_Result]=R[P_Right];
P_Right++;P_Result++;
}
}
while(P_Left<=mid)
{
T[P_Result]=R[P_Left];
P_Left++;P_Result++;
}
while(P_Right<=high)
{
T[P_Result]=R[P_Right];
P_Right++;P_Result++;
}
for(int i=low;i<P_Result;i++)
{
R[i]=T[i];
}//将中间数组的值赋到原数组的对应位置
}//将两个有序的序列归并一个有序的序列，跟求并集一样。
void MSort(int R[],int low,int high,int Temp[])
{
if(low<high){
int mid=(low+high)/2;
MSort(R,low,mid,Temp); //递归公式
MSort(R,mid+1,high,Temp);//递归公式
Merge(R,low,mid,high,Temp);
}
}

5.2.2非递归实现

因为单个元素一定有序，不用进行划分，直接两两进行归并，直到最后只有两个归并块为止。

5.3复杂度分析

时间复杂度：O(NlogN);空间复杂度：O(N）；稳定！

6、快速排序

6.1思路

快速排序也是基于分治思想提出的，找一个“杠杆”，杠杆左边都比“杠杆”元素”小”，右边都比“杠杆”元素“大”，

然后对“杠杆”左边和右边分别进行递归即可。

6.2代码实现

有最左侧元素做“枢轴”，存入“哨所”。（枢轴元素的选择会影响算法的速度）设low和high指向两端，high向左移动，一旦遇到小于枢纽的元素，则将其移动到左侧，放入low指向的位置；low向右移动，一旦遇到大于枢轴的元素，则将其移动到右侧，放入high指向的位置；high和low如此移动下去，直到high==low，记录下枢轴的位置，此时杠杆左边都比“杠杆”元素”小”，右边都比“杠杆”元素“大”。

int Partition(int *a,int low,int high)
{
a[0]=a[low];
while(low<high)
{
while(high>low&&a[high]>=a[0])//防止在找的过程中high==low
high--;
a[low]=a[high];
while(low<high&&a[low]<=a[0])
low++;
a[high]=a[low];
}
a[low]=a[0];
return low;
}
void Qsort(int *a,int low,int high)
{
if(low<high)
{
int Partition_=Partition(a,low,high);
Qsort(a,low,Partition_-1);
Qsort(a,Partition_+1,high);
}
}

6.3复杂度分析

平均复杂度：O(NlogN) 平均最快（因为不要脸，不跟基数排序玩….23333)

最坏时间复杂度：O(N^2);

平均空间复杂度：O(logN);

最坏空间复杂度：O(N);

改进：枢轴在两侧与中间中择一。

不稳定！！！

三：基于贪心思想设计的选择排序算法

1、简单选择排序

1.1思路

每一趟选择出当前最小的交换到最前面，至多N-1趟排序完成。

1.2代码实现

void selectSort(int *a,int N)

{

for(int i=1;i<=N-1;i++)

{

int minn=i;

for(int j=i+1;j<=N;j++)

{

if(a[minn]>a[j])

minn=j;

}

if(minn!=i)

{

int temp=a[minn];

a[minn]=a[i];

a[i]=temp;

}

}

}

1.3复杂度分析

时间复杂度：O(n^2);

空间复杂度O(1);

不稳定！！！

1.4不稳定的原因分析

举个栗子，3、3*、3**、2。将这一组数从小到大排列，三后面的* 用来标记三出现的先后顺序。按照上面给出的选择排序代码，第一次找最小的数的时候，将2跟3交换，原序列中第一个3在排完序之后成了最后一个。所以是不稳定，但这种不稳定可以改进，下面便给出再时间复杂度和空间复杂度都不变的情况下，一个稳定的选择排序算法。

2、简单排序算法的稳定性改进

2.1思路

再找到最小元素的下标minn是，不直接将他与a[i]交换，而是在i+1与minn之间找与a[i]相等的元素，找到就让a[i]和找到的元素交换。这样，最多讲过n-i次交换就可以保证其a[i]成为离a[minn]最近并且与无序块首记录关键字相等的元素，此时再将a[i]和a[minn]交换，则排序算法保持稳定性。

2.2代码实现

void selectSort(int *a,int N)
{
for(int i=1;i<=N-1;i++)
{
int minn=i;
for(int j=i+1;j<=N;j++)
{
if(a[minn]>a[j])
minn=j;
}
if(minn!=i)
{
for(int k=i+1;k<minn;k++)
{
if(a[k]==a[i])
{
int temp=a[k];
a[k]=a[i];
a[i]=temp;
}
}
int temp=a[minn];
a[minn]=a[i];
a[i]=temp;
}
}
}

2.3复杂度分析

比简单排序稍慢，但从复杂度分析的角度，其时间复杂度并没有提高，都是O(n^2)。其空间复杂度也是O(1),也没有发生改变。

2.4稳定性分析

同样举个例子，3、3-、3–、2。将这一组数从小到大排列，三后面的- 用来标记三出现的先后顺序。按照上面的排序中算法，在与无序块首记录关键字相等的元素交换的过程中，第一次得到的序列是 3-、3、3–、2，第二次得到的序列是，3–、3、3- 、2。最后再将2和3–交换，得到的就是2、3、3-、3–这个序列，可以看到，按照改进的排序算法并没有改变原序列中想等元素的顺序，所以改进的选择排序算法是稳定的！！！

具体参考论文http://kns.cnki.net/KCMS/detail/detail.aspx?dbcode=CJFQ&dbname=CJFDLAST2016&filename=RJDK201602023&uid=WEEvREcwSlJHSldRa1FhcTdWZDhML2VlZDlxK0FHL2ZORXFRR1pZL3ZxND0=

四：基于动态规划设计的冒泡排序算法

1、动态规划的思想

问题分解：全局问题分解为局部问题。

迭代求解：由初始阶段逐步递推，前一阶段影响后一阶段知道最终得到全局解。

2、冒泡排序

2.1思路

每一趟排序，每一躺排序时，从首记录开始相邻两数进行比较，逆序则交换，每趟排序都会使当前“最大”的数“沉到末尾”，小数则逐步“上升”，重复n-1趟排序完成。怎么改进？这样会出现重复操作的情况，即在中间的某一趟已经排序完成了，但他仍会执行后面无意义的操作。那么怎么判断他已经排序完成了呢，即在中间的某趟没有发生交换既证明排序已经结束。

2.2代码实现

void bubbleSort(int *a,int N)
{
for(int i=1;i<N;i++)
{
int flag=0;
for(int j=1;j<=N-i;j++)
{
int temp;
if(a[j+1]<a[j])
{
flag=1;
temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
if(flag==0)
break;
}
}

2.3复杂度分析

最好的情况：序列开始就有序的情况。时间复杂度O(n);

最坏的情况：序列逆序的情况。时间复杂度O(n^2);

这两种情况的空间复杂度都为O(1);

稳定！

五：基于逆向思维设计的基数排序算法

1、思路

所有排序都必须要有的一个原子操作就是就是比较，那如何不比较也能排序呢？这种不比较也能排序的算法就是基数排序，基数排序的提出是循序渐进的，他是先解决了一个最简单的问题，即关键字不重复，取值范围有限，即分配排序。然后解决了一个稍微复杂的问题即，关键字可重复，取值范围有限，即桶排序。最后便是关键字可重复，取值范围大，这里采用的解决办法是多趟分配与收集，每一趟范围小。在我看来，这里也体现了动态规划的思想。

2、代码实现

从个位数开始分别进行分配和收集，每趟的分配都存到队列数组中，然后顺序收集。

下面的代码是对int型正数进行排序，如果有负数要单独处理。

for(int i=1;i<=10;i++)
{
Distribute(a,S,i,N);
collect(a,S);
}
void Distribute(int *a,LinkQueue* S,int k,int N)
{
int temp;
for(int i=0;i<N;i++)
{    temp=a[i];
for(int j=1;j<k;j++)
{
temp=temp/10;
}
temp%=10;
EnQueue(S[temp],a[i]);
}
}
void collect(int *a,LinkQueue* S)
{
int j=0;
for(int i=0;i<10;i++)
{
while(S[i].front_!=S[i].rear_)
DeQueue(S[i],a[j++]);
}
}

3、复杂度分析

时间复杂度：O(n+radix) ；

空间复杂度 ： O(n+radix);

稳定！！！漂亮啊！！！

六：基于以（zhen）退（long）为（qi）进（ju）思想设计的堆排序

1、堆排序的引入

第一趟选择极值元素时，能否多作些工作，为后面选择极值元素带来便利呢。

2、堆排序

2.1思路

小顶堆对应的完全二叉树中任意结点均比其孩子小或者相等；大顶堆对应的完全二叉树中任意结点均比其孩子大或相等。

小顶堆堆顶（首元素）最小，大顶堆堆顶最大，子树也是堆。

基本思想：利用堆每次选择出最大的交换到末尾。

具体方法：

(1)先建初始大顶堆；

(2)堆顶与堆尾互换(最大记录换到最后）；忽略堆尾，将前N-1个记录组成的树重新调整成大顶
9f7c
堆；

(3)重复上一步N-1趟即可

2.2代码实现

Floyd在实现堆排序的过程中也运用到了以退为进的思想，先假设得到了初始大顶堆，即先解决了第二步筛选后，运用第二问的结论调整建堆建立初始大顶堆。

2.2.1筛选的实现

备份堆顶，较堆顶与其两个孩子，若堆顶不是最大的则将两个孩子中大的“上移”，之后的子树可能不再是堆，重复上述操作至最后（当前堆顶大于等于孩子或无孩子）

2.2.2建立初始大顶堆

从最后一个非叶子结点向根结点方向逐步调整建堆。

void HeapSort(int *a,int N)
{
for(int i=N/2;i>0;i--) //第一个非叶子结点是N/2
HeapAdjust(a,i,N);
for(int i=N;i>1;i--)
{
int temp=a[1];
a[1]=a[i];
a[i]=temp;
HeapAdjust(a,1,i-1);
}

}
void HeapAdjust(int *a,int k,int N)
{
a[0]=a[k];
for(int i=2*k;i<=N;i*=2)//i*2变成i对应的左孩子
{
if(i<N&&a[i]<a[i+1])//避免i==N的情况
i++;//i始终指向指向大孩子
if(a[0]>=a[i]) break;
else
{
a[k]=a[i];
k=i;
}

}
a[k]=a[0];
}

2.3复杂度分析

最坏时间复杂度：O(nlogn);

空间复杂度：O(1);

不稳定!!!

———————————————————–分界线——————————————————–

鲁大师好多课件都有的一句话：狡黠者鄙读书，无知者羡读书，惟明智之士用读书，然书并不以用处告人，用书之智不在书中，而在书外，全凭观察得之。共勉！！！