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

原文参考：http://www.cnblogs.com/Anker/archive/2013/01/22/2871042.html

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)
        {
         
            datas[i+1] = datas[i];
            i--;   //向前移动
        }
        datas[i+1] = key;  //最终确定待插入元素的位置
    }
}

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语言完整实现这两种方法，程序如下：

#include<stdio.h>
#include<malloc.h>
#define MAXLIMIT 65535

void MERGE(int *data,int p, int q, int r){
    int i,j,k;
    int n1 = q-p+1;
    int n2 = r-q;
    int *left = (int *)malloc((n1+1)*sizeof(int));
    int *right = (int *)malloc((n2+1)*sizeof(int));

    for(i=0;i<n1;i++) {
        *(left+i) = *(data+p+i);
    }
    for(j=0;j<n2;j++){
        *(right+j) = *(data+q+j+1);
    }

    *(left+n1) = MAXLIMIT;
    *(right+n2) = MAXLIMIT;
    i=0;
    j=0;
    for(k=p;k<=r;k++) {
        if(*(left+i) <= *(right+j)) {
            data[k] = *(left+i);
            i = i+1;
        }
        else{
            data[k] = *(right+j);
            j = j+1;
        }
    }
33｝ 


void MERGE_SORT(int data[], int p, int r) {
    int q;
    if(p < r) {
        q = (p+r)/2;
        MERGE_SORT(data, p, q);
        MERGE_SORT(data, q+1, r);
        MERGE(data,p,q,r);
    }
}
void main() {
    int A[8]={1, 3, 8, 5, 2, 13, 4, 9};
    int i;
    //printf("%x",A);
    MERGE_SORT(A,0,7);
    for(i=0; i<8; i++) {
        printf("%d",A[i]);
    }
}

另外参考一篇博客http://www.cnblogs.com/bluestorm/archive/2012/09/06/2673138.html

程序也不错：

/**
 * Merge_Sort: 归并排序的递归实现
 * 注：算法导论上给出的合并排序算法
 * 递归过程是将待排序集合一分为二，
 * 直至排序集合就剩下一个元素为止，然后不断的合并两个排好序的数组
 * T(n) = O(nlgn)
**/
#include <stdio.h>
#define LEN 8

// 合并
void merge(int a[], int start, int mid, int end)
{
    int n1 = mid - start + 1;
    int n2 = end - mid;
    int left[n1], right[n2];
    int i, j, k;

    for (i = 0; i < n1; i++) /* left holds a[start..mid] */
        left[i] = a[start+i];
    for (j = 0; j < n2; j++) /* right holds a[mid+1..end] */
        right[j] = a[mid+1+j];

    i = j = 0;
    k = start;
    while (i < n1 && j < n2)
        if (left[i] < right[j])
            a[k++] = left[i++];
        else
            a[k++] = right[j++];

    while (i < n1) /* left[] is not exhausted */
        a[k++] = left[i++];
    while (j < n2) /* right[] is not exhausted */
        a[k++] = right[j++];
}

// merge_sort()：先排序，再合并
void merge_sort(int a[], int start, int end)
{
    int mid;
    if (start < end)
    {
        mid = (start + end) / 2;
        printf("sort (%d-%d, %d-%d) %d %d %d %d %d %d %d %d\n",
               start, mid, mid+1, end,
               a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);

        // 分解 + 解决：Divide + Conquer
        merge_sort(a, start, mid); // 递归划分原数组左半边array[start...mid]
        merge_sort(a, mid+1, end); // 递归划分array[mid+1...end]
        // 合并：Combine
        merge(a, start, mid, end); // 合并

        printf("merge (%d-%d, %d-%d) to %d %d %d %d %d %d %d %d\n",
               start, mid, mid+1, end,
               a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
    }
}

int main(void)
{
    int a[LEN] = { 5, 2, 4, 7, 1, 3, 2, 6 };
    merge_sort(a, 0, LEN-1);

    return 0;
}

 

3、课后习题

　　有地道题目比较有意思，认真做了做，题目如下：

方法1：要求运行时间为θ（nlgn），对于集合S中任意一个整数a，设b=x-a，采用二分查找算法在S集合中查找b是否存在，如果b存在说明集合S中存在两个整数其和等于x。而二分查找算起的前提是集合S是有序的，算法时间为θ（lgn），因此先需要采用一种时间最多为θ(nlgn)的算法对集合S进行排序。可以采用归并排序算法，这样总的运行时间为θ（nlgn），满足题目给定的条件。

具体实现步骤：

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

2、对集合S中任意整数a，b=x-a，采用二分查找算法b是否在集合S中，若在则集合S中存在两个整数其和等于x，如果遍历了S中所有的元素，没能找到b，即集合S中不存在两个整数其和等于x。ps：自己犯得错，二分查找时，让递归处在while循环中，导致一直无法退出循环

代码：

 

#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)//变换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;
}
#if(0) //自己的错误方法,递归处在while循环之下多半就是有问题的
//递归形式二分查找
int binary_search_recursive(int *datas,int beg,int end,int obj)
{
    int pos = (beg+end)/2;
    while(beg < end) {
        if(obj<datas[pos]){
            binary_search_recursive(datas,beg,pos,obj);
        }
        else if(obj>datas[pos]) {
            binary_search_recursive(datas,pos,end,obj);
        }
        else
            return -1;
    }
    return 0;
}
#endif
#if(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;
}
#endif
//合并子程序
void merge(int *datas,int p,int q,int r)
{
    //int n1 = p-q+1;//粗心导致的错误！！！！
    int n1= q-p+1;
    int n2 = r-q;
    int k,i,j;

    int left[n1],right[n2];//malloc方法也行的
   for (i = 0; i < n1; i++) /* left holds a[start..mid] */
       left[i] = datas[p+i];
   for (j = 0; j < n2; j++) /* right holds a[mid+1..end] */
       right[j] = datas[q+1+j];
    //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) {
            break;
        }
        if(left[i]<=right[j]){
            datas[k] = left[i];
            i++;
        }
        else {
            datas[k] = right[j];
            j++;
        }
    }
    while(i!=n1) {
        datas[k++] = left[i++];
    }
    while(j!=n2) {
        datas[k++] = right[j++];
    }

}
//归并排序
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。