《算法导论》读书笔记之第2章 算法入门

　　本章通过介绍插入排序和归并排序两种常见的排序算法来说明算法的过程及算法分析，在介绍归并排序算法过程中引入了分治（divide-and-conquer）算法策略。

1、插入排序

　　输入：n个数（a1,a2,a3,...,an）

　　输出：输入序列的一个排列（a1',a2',a3',...an'）使得（a1'≤a2'≤a3'≤...≤an'）。

　　插入排序的基本思想是：将第i个元素插入到前面i-1个已经有序的元素中。具体实现是从第2个元素开始（因为1个元素是有序的），将第2个元素插入到前面的1个元素中，构成两个有序的序列，然后从第3个元素开始，循环操作，直到把第n元素插入到前面n-1个元素中，最终使得n个元素是有序的。该算法设计的方法是增量方法。书中给出了插入排序的为代码，并采用循环不变式证明算法的正确性。我采用C语言实插入排序，完整程序如下：

void insert_sort(int *datas,int length)
{
int i,j;
int key,tmp;
//判断参数是否合法
if(NULL == datas || 0==length)
{
printf("Check datas or length.\n");
exit(1);
}
//数组下标是从0开始的，从第二个元素（对应下标1）开始向前插入
for(j=1;j<length;j++)
{
key = datas[j];  //记录当前要插入的元素
i = j-1;  //前面已经有序的元素
//寻找待插入元素的位置，从小到到排序，如果是从大到小改为datas[i]<key
while(i>=0 && datas[i] > key)
{
/×tmp = datas[i+1];
datas[i+1] = datas[i];
datas[i] = tmp;×/  这个过程不需要进行交换，因为要插入的值保存在key中，没有被覆盖掉，在此感谢”两生花“指出问题所在
datas[i+1] = datas[i];
i--;   //向前移动
}
datas[i+1] = key;  //最终确定待插入元素的位置
}
}

插入排序算法的分析

　　算法分析是对一个算法所需的资源进行预测，资源是指希望测度的计算时间。插入排序过程的时间与输入相关的。插入排序的最好情况是输入数组开始时候就是满足要求的排好序的，时间代价为θ(n)，最坏情况下，输入数组是按逆序排序的，时间代价为θ(n^2)。

2、归并排序

　　归并排序采用了算法设计中的分治法，分治法的思想是将原问题分解成n个规模较小而结构与原问题相似的小问题，递归的解决这些子问题，然后再去合并其结果，得到原问题的解。分治模式在每一层递归上有三个步骤：

分解（divide）：将原问题分解成一系列子问题。

解决（conquer）：递归地解答各子问题，若子问题足够小，则直接求解。

合并（combine）：将子问题的结果合并成原问题的解。

归并排序（merge sort）算法按照分治模式，操作如下：

分解：将n个元素分解成各含n/2个元素的子序列

解决：用合并排序法对两个序列递归地排序

合并：合并两个已排序的子序列以得到排序结果

　　在对子序列排序时，长度为1时递归结束，单个元素被视为已排序好的。归并排序的关键步骤在于合并步骤中的合并两个已经有序的子序列，引入了一个辅助过程，merge(A,p,q,r)，将已经有序的子数组A[p...q]和A[q+1...r]合并成为有序的A[p...r]。书中给出了采用哨兵实现merge的伪代码，课后习题要求不使用哨兵实现merge过程。在这个两种方法中都需要引入额外的辅助空间，用来存放即将合并的有序子数组，总的空间大小为n。现在用C语言完整实现这两种方法，程序如下：

//采用哨兵实现merge
#define MAXLIMIT    65535
void merge(int *datas,int p,int q,int r)
{
int n1 = q-p+1;  //第一个有序子数组元素个数
int n2 = r-q;      //第二个有序子数组元素个数
int *left = (int*)malloc(sizeof(int)*(n1+1));
int *right = (int*)malloc(sizeof(int)*(n2+1));
int i,j,k;
//将子数组复制到临时辅助空间
for(i=0;i<n1;++i)
left[i] = datas[p+i];
for(j=0;j<n2;++j)
right[j] = datas[q+j+1];
//添加哨兵
left[n1] = MAXLIMIT;
right[n2] = MAXLIMIT;
//从第一个元素开始合并
i = 0;
j = 0;
//开始合并
for(k=p;k<=r;k++)
{
if(left[i] < right[j])
{
datas[k] = left[i];
i++;
}
else
{
datas[k] = right[j];
j++;
}
}
free(left);
free(right);
}

不采用哨兵实现，需要考虑两个子数组在合并的过程中哪一个先合并结束，剩下的那个子数组剩下部分复制到数组中，程序实现如下：

int merge(int *datas,int p,int q,int r)
{
int n1 = q-p+1;
int n2 = r-q;
int *left = (int*)malloc(sizeof(int)*(n1+1));
int *right = (int*)malloc(sizeof(int)*(n2+1));
int i,j,k;
memcpy(left,datas+p,n1*sizeof(int));
memcpy(right,datas+q+1,n2*sizeof(int));
i = 0;
j = 0;
for(k=p;k<=r;++k)
{
if(i <n1 && j< n2)  //归并两个子数组
{
if(left[i] < right[j])
{
datas[k] = left[i];
i++;
}
else
{
datas[k] = right[j];
j++;
}
}
else
break;
}
//将剩下的合并到数组中
while(i != n1)
datas[k++] = left[i++];
while(j != n2)
datas[k++] = right[j++];
free(left);
free(right);
}

merge过程的运行时间是θ(n)，现将merge过程作为归并排序中的一个子程序使用，merge_sort(A,p,r),对数组A[p...r]进行排序，实例分析如下图所示：View Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//非递归二叉查找
int binary_search(int *datas,int length,int obj)
{
int low,mid,high;
low = 0;
high = length;
while(low < high)
{
mid = (low + high)/2;
if(datas[mid] == obj)
return mid;
else if(datas[mid] > obj)
high = mid;
else
low = mid+1;
}
return -1;
}

//递归形式二分查找
int binary_search_recursive(int *datas,int beg,int end,int obj)
{
int mid;
if(beg < end)
{
mid = (beg+end)/2;
if(datas[mid] == obj)
return mid;
if(datas[mid] > obj)
return binary_search_recursive(datas,beg,mid,obj);
else
return binary_search_recursive(datas,mid+1,end,obj);

}
return -1;
}
//合并子程序
int merge(int *datas,int p,int q,int r)
{
int n1 = q-p+1;
int n2 = r-q;
int *left = (int*)malloc(sizeof(int)*(n1+1));
int *right = (int*)malloc(sizeof(int)*(n2+1));
int i,j,k;
memcpy(left,datas+p,n1*sizeof(int));
memcpy(right,datas+q+1,n2*sizeof(int));
i = 0;
j = 0;
for(k=p;k<=r;++k)
{
if(i <n1 && j< n2)
{
if(left[i] < right[j])
{
datas[k] = left[i];
i++;
}
else
{
datas[k] = right[j];
j++;
}
}
else
break;
}
while(i != n1)
datas[k++] = left[i++];
while(j != n2)
datas[k++] = right[j++];
free(left);
free(right);
}
//归并排序
void merge_sort(int *datas,int beg,int end)
{
int pos;
if(beg < end)
{
pos = (beg+end)/2;
merge_sort(datas,beg,pos);
merge_sort(datas,pos+1,end);
merge(datas,beg,pos,end);
}
}

int main(int argc,char *argv[])
{
int i,j,x,obj;
int datas[10] = {34,11,23,24,90,43,78,65,90,86};
if(argc != 2)
{
printf("input error.\n");
exit(0);
}
x = atoi(argv[1]);
merge_sort(datas,0,9);
for(i=0;i<10;i++)
{
obj = x - datas[i];
j = binary_search_recursive(datas,0,10,obj);
//j = binary_search(datas,10,obj);
if( j != -1 && j!= i)  //判断是否查找成功
{
printf("there exit two datas (%d and %d) which their sum is %d.\n",datas[i],datas[j],x);
break;
}
}
if(i==10)
printf("there not exit two datas whose sum is %d.\n",x);
exit(0);
}

程序执行结果如下：



方法2：网上课后习题答案上面给的一种方法，具体思想如下：

1、对集合S进行排序，可以采用归并排序算法

2、对S中每一个元素a，将b=x-a构造一个新的集合S'，并对S’进行排序

3、去除S和S'中重复的数据

4、将S和S'按照大小进行归并，组成新的集合T，若干T中有两队及以上两个连续相等数据，说明集合S中存在两个整数其和等于x。

例如：S={7,10,5,4,2,5}，设x=11，执行过程如下：

对S进行排序，S={2,4,5,5,7,10}。

S'={9,7,6,6,4,1},排序后S’={1,4,6,6,7,9}。

去除S和S'中重复的数据后S={2,4,5,7,10}，S'={1,4,6,7,9}

归纳S和S'组成新集合T={1,2,4,4,5,6,7,7,9,10}，可以看出集合T中存在两对连续相等数据4和7，二者存在集合S中，满足4+7=11。