《数据结构与算法分析-C语言描述》笔记

第一章 引论

    观念：写出一个可以工作的程序并不够。如果这个程序在巨大的数据集上运行，那么运行时间就变成了重要的问题。

第二章 算法分析 

    2.4.3 最大子序列和问题的解

  

算法1 O(N^3)

le062@Ubuntu20120606102912:~/algorithm$ cat source2-4-3_1.c
#include <stdio.h>
#include <stdlib.h>

int MaxNum(int* number,int n);

int main(void)
{
        int i,N,A[100000];
        printf("Please input the Number!\n");
        scanf("%d",&N);
        srand((unsigned)time(NULL));
        for(i=0;i<=N;i++)
        {
                A[i]=rand()%20001-10000;
                //printf("\n%d",A[i]);
        }
        printf("%d\n",MaxNum(A,N));
        return 0;
}

int MaxNum(int* number,int n)
{
        int thissum,maxsum,i,j,k;
        maxsum=0;
        for(i=0;i<n;i++)
                for(j=i;j<n;j++)
                {
                        thissum=0;
                        for(k=i;k<=j;k++)
                                thissum+=*(number+k);
                        if(thissum>maxsum)
                                maxsum=thissum;
                }
        return maxsum;
}
le062@Ubuntu20120606102912:~/algorithm$ gcc -W source2-4-3_1.c -o source2-4-3_1
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_1 
Please input the Number!
10
21250

real    0m0.880s
user    0m0.000s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_1 
Please input the Number!
100
66205

real    0m1.281s
user    0m0.000s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_1 
Please input the Number!
500
87528

real    0m1.738s
user    0m0.150s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_1 
Please input the Number!
1000
119906

real    0m3.137s
user    0m0.870s
sys     0m0.060s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_1 
Please input the Number!
2000
304389

real    0m9.127s
user    0m5.740s
sys     0m0.090s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_1 
Please input the Number!
4000
722457

real    1m3.492s
user    0m44.890s
sys     0m0.800s

 

算法2 O(N^2)

le062@Ubuntu20120606102912:~/algorithm$ vi source2-4-3_2.c

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

int MaxNum(int* number,int n);

int main(void)
{
        int i,N,A[100000];
        printf("Please input the Number!\n");
        scanf("%d",&N);
        srand((unsigned)time(NULL));
        for(i=0;i<=N;i++)
        {
                A[i]=rand()%20001-10000;
                //printf("\n%d",A[i]);
        }
        printf("%d\n",MaxNum(A,N));
        return 0;
}

int MaxNum(int* number,int n)
{
        int thissum,maxsum,i,j;
        maxsum=0;
        for(i=0;i<n;i++)
        {
                thissum=0;
                for(j=i;j<n;j++)
                {
                        thissum+=*(number+j);
                        if(thissum>maxsum)
                                maxsum=thissum;
                }
        }
        return maxsum;
}
"source2-4-3_2.c" 36L, 533C written                  
le062@Ubuntu20120606102912:~/algorithm$ gcc -W source2-4-3_2.c -o source2-4-3_2
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_2
Please input the Number!
10
13510

real    0m0.960s
user    0m0.000s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_2
Please input the Number!
100
115320

real    0m1.340s
user    0m0.000s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_2
Please input the Number!
1000
197663

real    0m1.473s
user    0m0.000s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_2
Please input the Number!
10000
433957

real    0m2.423s
user    0m0.280s
sys     0m0.000s
le062@Ubuntu20120606102912:~/algorithm$ time ./source2-4-3_2
Please input the Number!
100000
1587627

real    0m42.028s
user    0m28.030s
sys     0m0.640s

 

算法3 O(N log N)

int max_sub_sum( int a[], int left, int right )
{ 
	int max_left_sum, max_right_sum;	
	int max_left_border_sum, max_right_border_sum;	
	int left_border_sum, right_border_sum;	
	int center, i;

/*1*/		if ( left == right )      /* Base Case */
/*2*/			if( a[left] > 0 )	
/*3*/                 return a[left];  
				else		   
/*4*/                return 0; 

/*5*/		center = (left + right )/2;	
/*6*/		max_left_sum = max_sub_sum( a, left, center );	
/*7*/       max_right_sum = max_sub_sum( a, center+1, right );
/*8*/       max_left_border_sum = 0; left_border_sum = 0;  
/*9*/       for( i=center; i>=left; i-- )	
			{				
/*10*/           left_border_sum += a[i]; 
/*11*/           if( left_border_sum > max_left_border_sum ) 
/*12*/                max_left_border_sum = left_border_sum; 
			}	
/*13*/      max_right_border_sum = 0; right_border_sum = 0;	   
/*14*/      for( i=center+1; i<=right; i++ )
			{	   
/*15*/           right_border_sum += a[i];
/*16*/           if( right_border_sum > max_right_border_sum ) 
/*17*/                max_right_border_sum = right_border_sum;
			} 
/*18*/      return max3( max_left_sum, max_right_sum,max_left_border_sum + max_right_border_sum );

}

int max_sub_sequence_sum( int a[], unsigned int n )	  
{	 
	return max_sub_sum( a, 0, n-1 ); 
}

 

算法4 O(N)

int max_subsequence_sum( int a[], unsigned int n ) 	 
{		  
			int this_sum, max_sum, best_i, best_j, i, j;
/*1*/       i = this_sum = max_sum = 0; best_i = best_j = -1; 
/*2*/       for( j=0; j<n; j++ )				 
			{									 
/*3*/           this_sum += a[j];	 
/*4*/           if( this_sum > max_sum )
				{    /* update max_sum, best_i, best_j */  
/*5*/                max_sum = this_sum;	 
/*6*/                best_i = i;			 
/*7*/                best_j = j;			 
				}											 
				else										 
/*8*/           if( this_sum < 0 )			 
				{											 
/*9*/           	i = j + 1;				 
/*10*/          	this_sum = 0;			 
				}											 
			}											 
/*11*/      return( max_sum );				 
}

2.4.4 运行时间中的对数

对分查找

int

binary_search( input_type a[ ], input_type x, unsigned int n )

{

int low, mid, high;       /* Can't be unsigned; why? */



/*1*/       low = 0; high = n - 1;

/*2*/       while( low <= high )

{

/*3*/            mid = (low + high)/2;

/*4*/            if( a[mid] < x )

/*5*/                 low = mid + 1;

else

/*6*/           if ( a[mid] < x )

/*7*/                 high = mid - 1;

else

/*8*/                return( mid );  /* found */

}

/*9*/       return( NOT_FOUND );

}

 

欧几里德算法 

unsigned int gcd( unsigned int m, unsigned int n )
{
unsigned int rem;
/*1*/       while( n > 0 )
{
/*2*/            rem = m % n;
/*3*/            m = n;
/*4*/            n = rem;
}
/*5*/       return( m );
}

 

第三章

习题3.1    编写打印出一个链表所有元素的程序

/*前些日子编译环境都是利用SSH在远端linux下，现在安装了个CODEBLOCKS，效果很好*/


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

struct list
{
    struct list* listp;
    int gogogo;
};


int main()
{
    struct list *header,*temp;
    header = malloc(sizeof(struct list));
    temp=header;
    for(int i=0;i<100;i++)
    {
        temp->gogogo=i;
        temp->listp=malloc(sizeof(struct list));
        temp=temp->listp;
    }
    temp->listp=NULL;

    temp=header;
    while(temp->listp!=NULL)
    {
        printf("%d\n",temp->gogogo);
        temp=temp->listp;
    }

    printf("Hello world!\n");
    return 0;
}

 

3.10  约瑟夫环

对于 Josephus Problem 的一些算法

Josephus Problem 大家应该耳熟能详了吧，这里不再赘述
下文提到的 n 均指初始时人数，报数报到 m 退出

Ο(n * m)
用线性表实现的朴素方法多属于此类

Ο(n * log(m))
使用 BST，可以求出完整的退出序列
利用 BST 能在 Ο(log(n)) 求 n 个数中第 k 个数的性质，
每次求出要删除那个编号

Ο(n)
动态规划，s_n = (s_{n-1} + m) % n，这里编号从0开始

如果求出了 n-1 的人的情况下谁最后退出
那么对于 n 个人的情况，m-1 最早退出，
剩下 k k+1 ... n-1 0 1 ... k-2
每一项减去 k 并对 n 取模，得到 0 1 2 ... n-2，编号为 s_{n-1} 的人最后退出
还原为原来的编号，得到 (s_{n-1} + m) % n

Ο(log _ {m/(m-1)} ^ {k*m-n})
可以求出第 k 个退出的人的编号，
复杂度的含义是以 m/(m-1) 为底，k*m-n 的对数
如果忽略常数 m，求最后一个退出的人的编号可以在 Ο(log(n)) 时间内求出

把跳过的人编号添加到后面，1 -> n+1，2 -> n+2，...，m-1 -> n+m-1，m+1 -> n+m
对于编号 m*a+b，会变成 n+(m-1)*a+b
只要求出编号 m*k 原来的编号即可


这是后两种方法的实现，kth 就是那个复杂度描述很复杂的算法
last 是 Ο(n) 的动态规划算法

#include <assert.h>
#include <stdio.h>

int kth(int n, int m, int k)
{
    for (k *= m; k > n; k = k-n+(k-n-1)/(m-1));
    return k;
}

int last(int n, int m)
{
    int s = 0;
    for (int i = 2; i <= n; i++)
        s = (s+m)%i;
    return s+1;
}

int main(void)
{
    int n, m;
    while (scanf("%d%d", &n, &m) == 2) {
        assert(n >= 2 && m > 1);
        printf("%d %d\n", kth(n, m, n-1), kth(n, m, n));
        //printf("%d\n", last(n, m));
    }
    return 0;
}

-------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/timeb.h>

/*
int algorithm(int Num,int M)
{

    return Num;
}
*/

int kth(int n, int m, int k)
{
    for (k *= m; k > n; k = k-n+(k-n-1)/(m-1));
    return k;
}



int main()
{
    int N,M;
    struct timeb time1,time2;

    printf("How many children? ");
    scanf("%d",&N);
    printf("How much the M? ");
    scanf("%d",&M);
    ftime (&time1);

    //N=algorithm(N,M);
    N=kth(N,M,N);

    ftime (&time2);

    printf("\nThe last one is %d\n",N);

    printf("Running time is %.3fms\n",((float)(time2.time-time1.time)+((float)(time2.millitm-time1.millitm))/1000));



    return 0;
}