BlogJava-ChenGen-随笔分类-数据结构复习

杨辉三角

ChenGen — Wed, 04 Oct 2006 16:58:00 GMT

   前段时间复习了01背包问题的算法，受它的启发，我采用同样的数据结构来解决杨辉三角的问题。

   下面是这种数据结构的图示：

   数组 r 用来存储杨辉三角每一行的数据，那么 r 的大小就是 (n+1)n/2 ，其中 n 是杨辉三角的行数。数组 f 用来存储每一行开始位置的下标，如第一行从位置1开始，所以 f[1]=1；第四行从位置7开始，所以 f[4]=7。

   完整的程序如下(环境turbo c 2.0)：

#include "stdio.h"
#include "stdlib.h"

void Yanghui(int n);

void main(void)
{
    int n;
    printf("intput n: ");
    scanf("%d",&n);
    Yanghui(n);
}

void Yanghui(int n)
{
    int *r,*f;
    int i,j,k,next;
    r=(int *)malloc(sizeof(int)*( n*(n+1)/2+1 ));
    f=(int *)malloc(sizeof(int)*( n+2 ));
    r[1]=1;
    f[1]=1;
    f[2]=2;
    next=2;
    i=2;
    while(i<=n){
        r[next++]=1;//每行第一个位置是1
        for(j=f[i-1];j<f[i]-1;j++){
            r[next++]=r[j]+r[j+1];
        }
        r[next++]=1;//每行最后一个位置是1
        f[i+1]=next;//下一行的开始位置
        i++;
    }
    //输出
    for(i=1;i<=n;i++){
        for(j=1;j<=n-i;j++)
            printf("   ");
        for(j=f[i];j<f[i+1];j++){
            printf("%2d   ",r[j]);
        }
        printf("\n");
    }

}

ChenGen 2006-10-05 00:58 发表评论

复习动态规划算法——01背包问题

ChenGen — Thu, 28 Sep 2006 04:52:00 GMT

   今天复习了动态规划算法。01背包问题是一个典型的动态规划问题。算法的证明过程比较复杂，但是计算过程并不难理解。

   假设有这样的序列 n＝3 M=6 (物体数量为3，背包能背的重量为6)
   wi   2   3   4 (物体重量)
   pi    1   2   5 (物体的价值)

   初始化：Si={(P)}(待完成)

代码:

#include " stdio.h "
#include " stdlib.h "
#define MAXSIZE 1000

void DKNAP( int * , int * , int , int );
void PARTS( int * , int * , int * , int * , int , int );

void main( void )
{
     int i,j,n, * w, * p,M;
     if (freopen( " input.txt " , " r " ,stdin) == NULL) {
        printf( " can't open file 'input.txt'\n " );
        exit( - 1 );
    }
    scanf( " %d " , & n);
    scanf( " %d " , & M);
    w = ( int * )malloc(sizeof( int ) * n);
    p = ( int * )malloc(sizeof( int ) * n);
     for (i = 0 ;i < n;i ++ )
        scanf( " %d " , & w[i]);
     for (i = 0 ;i < n;i ++ )
        scanf( " %d " , & p[i]);
    DKNAP(w,p,n,M);
}

void DKNAP( int * w, int * p, int n, int M)
{
     int * f,l,h,k,next,u,i,j,pp,ww,m;
     int P[MAXSIZE],W[MAXSIZE];
    f = ( int * )malloc(sizeof( int ) * (n + 1 ));
    P[ 0 ] = 0 ;
    W[ 0 ] = 0 ;
    f[ 0 ] = next = 1 ;
    l = h = 0 ;
     for (i = 0 ;i < n;i ++ ) {
        k = l;
        j = h;
         while (W[j] + w[i] > M) j -- ;
        u = j;
         for (j = l;j <= u;j ++ ) {
            ww = W[j] + w[i];
            pp = P[j] + p[i];
             while (k <= h && W[k] < ww) {
                W[next] = W[k];
                P[next] = P[k];
                next ++ ;
                k ++ ;
            }
             if (k <= h && W[k] == ww) {
                pp = pp > P[k] ? pp:P[k];
                k ++ ;
            }
             if (pp > P[next - 1 ]) {
                P[next] = pp;
                W[next] = ww;
                next ++ ;
            }
             while (k <= h && P[k] < P[next - 1 ] ) k ++ ;
        }
         while (k <= h) {
            P[next] = P[k];
            W[next] = W[k];
            next ++ ;
            k ++ ;
        }
        f[i + 1 ] = next;
        l = h + 1 ;
        h = next - 1 ;

    }
    m = W[next - 1 ];
    printf( " \np max is %d \n " ,P[next - 1 ]);
    PARTS(W,w,p,f,n - 1 ,m);
}

void PARTS( int * W, int * w, int * p, int * f, int i, int m)
{
     int flag,j,k;
     while (m > 0 && i > 0 ) {
        flag = 0 ;
         for (j = f[i - 1 ];j < f[i];j ++ )
             if (W[j] == m) {
                flag = 1 ;
                 break ;
            }
         if (flag == 0 ) {
            printf( " %d\n " ,i);
            m -= w[i];
        }
        i -- ;
    }
     if (m > 0 ) printf( " %d\n " ,i);
}

ChenGen 2006-09-28 12:52 发表评论

复习回溯算法——N皇后问题

ChenGen — Wed, 27 Sep 2006 14:11:00 GMT

摘要: 今天复习了回溯算法。N皇后问题是一个典型的需要用回溯算法来解决的问题。回溯算法可以用递归方法来实现，也可以用非递归方法来实现。用递归的方法来解决回溯的问题思路很清晰，但是耗费的内存资源较多，速度也较慢；非递归方法具有速度快和耗费较少内存资源的优点，但是程序的逻辑结构却很复杂——不过搞懂之后觉得也很简单。在写非递归算法之前，参考了网上的一些文章，但是觉得那些程序都很晦涩难懂，而且存在一些问题，... 阅读全文

ChenGen 2006-09-27 22:11 发表评论

复习二叉排序树

ChenGen — Wed, 27 Sep 2006 06:33:00 GMT

二叉排序数是一种很重要的数据结构，今天复习了一下如何创建一棵二叉排序数＆二叉排序数的两种中序遍历方法——递归中序遍历＆非递归的中序遍历。

宏定义＆头文件：

#include " stdio.h "
#include " stdlib.h " /* 内存分配*/
#include " ctype.h " /* 字符操作*/
#define MAXNUM 100 /* 非递归时的栈的大小*/

数据结构：

typedef struct node {
     int data;
    struct node * left;
    struct node * right;
} Node;

生成一棵二叉排序数：

Node *CreateTree()
{
    int p,data;
    char buffer[100],ch;
    Node *head;
    head=NULL;    /*This is very important!*/
    while((ch=getchar())!=EOF){
        p=0;
        if(isspace(ch)) /*过滤空格*/
            continue;
        else if(isdigit(ch)){
            buffer[p++]=ch;
            for(ch=getchar();isdigit(ch);ch=getchar())
                buffer[p++]=ch;
            ungetc(ch,stdin);
            buffer[p]='\0';
            data=atoi(buffer); /*将字符串转化为整数*/
        }
        InsertNode(&head,data);/*向树中插入一个结点*/
    }
    return head;
}

void InsertNode(Node **head,int data)
{
    if(*head==NULL){ /*如果结点为空，正是要插入的位置*/
        *head=(Node *)malloc(sizeof(Node));
        (*head)->data=data;
        (*head)->left=NULL;
        (*head)->right=NULL;
    }
    else{
        if(data<(*head)->data) InsertNode(&((*head)->left),data);/*插入左子树*/
        else InsertNode(&((*head)->right),data);/*插入右子树*/
    }
}

二叉排序数的递归中序遍历：

void MidTravel(Node *head)
{
    if(head){
        MidTravel(head->left); /*遍历左子树*/
        printf("%d\t",head->data); /*输出结点值*/
        MidTravel(head->right); /*遍历又子树*/
    }
}

二叉排序数的非递归遍历：

void MidTravel2(Node *p)
{
    Node *a[MAXNUM]; /*栈*/
    int top; /*栈顶*/
    top=0;
    while(p || top){
        while(p){
            if(top==MAXNUM) {
                printf("over flow\n");
                exit(-1);
            }
            a[top++]=p; /*入栈*/
            p=p->left; /*遍历左子树*/
        }
        if(top){
            p=a[--top]; /*出栈*/
            printf("%d\t",p->data); /*输出结点值*/
            p=p->right; /*遍历右子树*/
        }
    }
}

ChenGen 2006-09-27 14:33 发表评论

复习排序算法2

ChenGen — Tue, 26 Sep 2006 15:42:00 GMT

   今天复习另外两种排序算法：Shell排序＆归并排序。

   Shell排序是插入排序的一种。昨天已经复习了两种插入排序算法——直接插入排序＆折半插入排序，Shell排序属于的三种插入排序算法。

   Shell排序的基本思路是将记录按照一定的间隔进行插入式排序，然后逐渐缩小间隔到1。当间隔缩小到1时，Shell排序相当于直接插入排序。但是因为前面的排序过程基本上已经定下了记录的大概位置，所以并不需要比较和移动很多记录。因此算法的效率要比直接插入排序好。

   Shell排序：

void ShellSort(RcdType r[],int n)
{
    int i,j,d;
    d=n/2;
    while(d>0){
        for(i=1+d;i<=n;i++){
            r[0]=r[i];
            j=i-d;
            while(j>0 && r[j].key>r[0].key){
                r[j+d]=r[j];
                j-=d;
            }
            r[j+d]=r[0];
        }
        d/=2;
    }
}

   今天复习的另外一种排序算法是归并排序。归并排序的基本思想是将两个有序记录集归并为一个有序的记录集。具体实现起来有两种方法，即所谓的自顶向下法和自底向上法。我个人认为自顶向下法更为简单。

   自顶向下的归并排序(运用递归)：

void Merge(RcdType r[],int l,int m,int h)
{
    int i,j,k,*r2;
    i=l;
    j=m+1;
    k=0;
    r2=(int *) malloc(sizeof(int)*(h-l+1));
    while(i<=m && j<==h){
        if(r[i].key<r[j].key) r2[k++]=r[i++];
        else r2[k++]=r[j++];
    }
    while(i<=m) r2[k++]=r[i++];
    while(j<=h) r2[k++]=r[j++];
    for(k=0,i=l;i<=h;)
        r[i++]=r2[k++];
    free(r2);
}

void MergeSort(RcdType r[],int s,int e)
{
    int m;
    if(s!=e){
        m=(s+e)/2;
        MergeSort(r,s,m);
        MergeSort(r,m+1,e);
        Merge(r,s,m,e);
    }
}

自底向上的归并排序：

void Merge(RcdType r[],int l,int m,int h)
{
    int i,j,k,*r2;
    i=l;
    j=m+1;
    k=0;
    r2=(int *) malloc(sizeof(int)*(h-l+1));
    while(i<=m && j<==h){
        if(r[i].key<r[j].key) r2[k++]=r[i++];
        else r2[k++]=r[j++];
    }
    while(i<=m) r2[k++]=r[i++];
    while(j<=h) r2[k++]=r[j++];
    for(k=0,i=l;i<=h;)
        r[i++]=r2[k++];
    free(r2);
}

void MergePass(RcdType r[],int length,int n)
{
    int i;
    for(i=1;i+length*2-1<=n;i=i+length*2){
        Merge(r,i,i+length-1,i+2*length-1);
    }
    if(i+length-1<n) Merge(r,i,i+length-1,n);
}

void MergeSort(RcdType r[],int n)
{
    int length;
    for(length=1;length<n;length*=2){
        MergePass(r,length,n);
    }
}

ChenGen 2006-09-26 23:42 发表评论

复习排序算法

ChenGen — Mon, 25 Sep 2006 08:01:00 GMT

摘要: 学院的保送研究生复试马上就要开始了，复试中最能拉开距离的就是笔试，这也是我发挥个人能力的地方。为了万无一失，我准备这几天复习一下数据结构，今天复习的内容是排序算法。一般的排序算法大体上分为三类——插入排序、交换排序和选择排序。插入排序的基本思想是将第N个记录插入到前面(N-1)个有序的记录当中。直接插入排序、折半插入排序和系尔排序都是属于插入排序。直接插入排序： ... 阅读全文

ChenGen 2006-09-25 16:01 发表评论