程序员数据结构笔记6

第六天

　　快考试了， 老师没有多说什么，他只是给我们讲了讲近三年试题情况，并详细讲述了两道题目：一道递归，另一道回溯。不过今天不知怎么回事，我感觉特别累，也特别想睡 觉。所以没什么感觉。这里就不说了，两道题目都有的，递归那题是2001年最后一题,回溯是在《程序员教程》P416，老师说高程曾经考过，有兴趣自己看 看也能看懂的。老师特意为我们出了一份下午试题，我现在把他拿出来让大家参考参考。到这里，就到这里！

程序员考试下午试题（模拟）

一、把一个字符串插入到另一个字符串的某个位置（指元素个数）之后
　　char *insert(char *s，char *t，int position)
　　{ int i;
　　　char *target;
　　　if（position>strlen(t)） printf("error");
　　　else
　　　{ for (i=0;i< （1） ;i++) 
　　　　{ if (i<position) 
　　　　　target[i]=s[i];
　　　　　else
　　　　　{ if(i< （2） ) 
　　　　　　target[i]=t[i]; 
　　　　　　else （3） ; 
　　　　　}
　　　　}
　　　}
　　　return garget;
　　}
二、辗转相除法求两个正整数的最大公约数
　　int f(int a,int b)
　　{ if (a==b) （4） ; 
　　　else
　　　{ if (a>b) return f(a-b,b); 
　　　　else （5） ;
　　　}
　　}
三、求一个链表的所有元素的平均值
　　typedef struct { int num;
　　　float ave;
　　}Back;
　　typedef struct node{ float data; 
　　　struct node *next;
　　} Node;

　　Back *aveage（Node *head）
　　{ Back *p,*q;
　　　p=（Back *）malloc（sizeof（Back））;
　　　if （head==NULL）
　　　{ p->num=0; 
　　　　p->ave=0; }
　　　else
　　　{ （6） ; 
　　　　p->num=q->num+1; 
　　　　（7） ; } 
　　　retuen p;
　　}

　　main()
　　{ Node *h; Back *p;
　　　h=create(); /*建立以h为头指针的链表*/
　　　if (h==NULL) printf("没有元素");
　　　else { p=aveage(h);
　　　　printf("链表元素的均值为：%6f",p->ave);
　　　}
　　}
四、希尔排序
　　已知待排序序列data[n]；希尔排序的增量序列为d[m]，其中d[]序列降序排列，且d[m-1]=1。其方法是对序列进行m趟排序，在第i趟排序中，按增量d[i]把整个序列分成d[i]个子序列，并按直接插入排序的方法对每个子序列进行排序。
希尔排序的程序为：
　　void shellsort(int *data,int *d,int n,int m)
　　{ int i,j;
　　　for (i=0;i<m;i++)
　　　for (j=0; （1） ;j++) 
　　　shell( （2） ); 
　　}

　　void shell(int *data,int d,int num,int n)
　　{ int i,j,k,temp;
　　　for (i=1; （3） ;i++) 
　　　{ j=0;
　　　　temp=data[j+i*d];
　　　　while ((j<i)&&( （4） )) 
　　　　j++;
　　　　for (k=j;k<i;k++) 
　　　　　data[k+1]=data[k];
　　　　（5） ; 
　　　　（6） }
　　}
五、求树的宽度
　　所谓宽度是指在二叉树的各层上，具有结点数最多的那一层上的结点总数。本算法是按层次遍历二叉树，采用一个队列q，让根结点入队列，最后出队列，若有左右子树，则左右子树根结点入队列，如此反复，直到队列为空。
　　int Width(BinTree *T)
　　{ int front=-1,rear=-1; /* 队列初始化*／
　　　int flag=0,count=0,p;/*p用于指向树中层的最右边的结点，flag记录层中结点数的最大值。*／
　　　if(T!=Null)
　　　{ rear++; （1） ; flag=1; p=rear; 
　　　}
　　　while( （2） ) 
　　　{ front++;
　　　　T=q[front];
　　　　if(T->lchild!=Null)
　　　　{ rear++; （3） ; count++; } //
　　　　　if(T->rchild!=Null)
　　　　　{ rear++; q[rear]=T->rchild; （4） ; } 
　　　　　if(front==p) /* 当前层已遍历完毕*/
　　　　　{ if( （5） ) flag=count; count=0; //
　　　　　　p=rear; /* p指向下一层最右边的结点*/ 
　　　　　}
　　　} 
　　　return(flag);
　　}
六、区间覆盖
　　设在实数轴上有n个点（x0，x1，……，xn-2，xn-1），现在要求用长度为1的单位闭区间去覆盖这n个点，则需要多少个单位闭区间。
　　int cover(float x[ ], int num)
　　{ float start[num],end[num];
　　　int i ,j ,flag, count=0;
　　　for (i=0;i<num;i++)
　　　{ flag=1;
　　　　for (j=0;j< （1） ;j++)
　　　　{ if ((start[j]>x[i])&&(end[j]-x[i]<=1)) （2） ;
　　　　　else if ( （3） ) end[j]=x[i];
　　　　　else if ((x[i]>start[j])&&(x[i]<end[j])) flag=0;
　　　　　if (flag) break;
　　　　}
　　　　if ( （4） )
　　　　　{ end[count]=x[i]; （5）; count++; }
　　　}
　　　return count-1;
　　}
　　start[count]=x[i]
七、围棋中的提子
　 　在围棋比赛中，某一方（假设为黑方）在棋盘的某个位置（i，j）下子后，有可能提取对方（白方的一串子）。以W[19][19]表示一个棋盘，若W [i][j]=0表示在位置（i，j）上没有子，W[i][j]=1表示该位置上的是黑子，W[i][j]=-1表示该位置上是白子。可以用回溯法实现提 子算法。
下列程序是黑棋（tag=1）下在（i，j）位置后判断是否可以吃掉某些白子，这些确定可以提掉的白子以一个线性表表示。
　　问题相应的数据结构有：
　　#define length 19 /*棋盘大小*/
　　#define max_num 361 /*棋盘中点的数量*/
　　struct position { int row; int col;
　　}; /*棋子位置*/
　　struct killed { struct position data[max_num]; int num;
　　} *p; /*存储可以吃掉的棋子位置*/
　　struct stack { struct position node[max_num]; int top;
　　}; /*栈*/
　　int w[length][length]; /*棋盘中双方的棋子分布*/
　　int visited[length][length]; /*给已搜索到的棋子位置作标记，初值为0，搜索到后为1*/

　　struct killed *kill(int w[length][length],int r,int c,int tag)
　　{ struct killed *p;
　　　struct position *s;
　　　struct stack S;
　　　for (i=0;i<length;i++)
　　　for (j=0;j<length;j++)
　　　　（1） ;
　　　S.top=-1; p->num=-1;
　　　if (w[r-1][c]==tag*(-1)) s->row=r-1; s->col=c;
　　　else if (w[r+1][c]==tag*(-1)) s->row=r+1; s->col=c;
　　　else if (w[r][c-1]==tag*(-1)) s->row=r; s->col=c-1;
　　　else if (w[r][c+1]==tag*(-1)) s->row=r; s->col=c+1;
　　　else p->len=0; return p;
　　　push(S,s); visited[s->row][s->col]=1;
　　　flag=search(s,tag);
　　　while ( （2）)
　　　{ push(S,s); visited[s->row][s->col]=1;
　　　　（3）;
　　　}
　　　while (S->top>=0)
　　　　{ pop(S);
　　　　　（4）;
　　　　　flag=search(s,tag);
　　　　　while (flag)
　　　　　{ push(S,s);
　　　　　　visit(s);
　　　　　　flag=search(s);
　　　　　}
　　　　}
　　}

　　void push( struct stack *S, struct position *s)
　　{ S->top++;
　　　S->node[S->top].row=s->row;
　　　S->node[S->top].col=s->col;
　　　p->num++;
　　　p->data[p->num].row=s->row;
　　　p->data[p->num].col=s->col;
　　}

　　void pop(struct stack *S)
　　{ S->top--;
　　}

　　struct position *gettop(struct stack *S)
　　{ struct position *s;
　　　s->row=S->data[S->top].row;
　　　s->row=S->data[S->top].row;
　　　return s;
　　}

　　int search(struct position *s,int tag)
　　{ int row,col;
　　　row=s->row; col=s->col;
　　　if (W[row+1][col]=(-1)*tag)&&(!visited[row+1][col])
　　　{ s->row=row+1;s->col=col; return 1;}
　　　if (W[row-1][col]=(-1)*tag)&&(!visited[row-1][col])
　　　{ s->row=row-1;s->col=col; return 1;}
　　　if (W[row][col+1]=(-1)*tag)&&(!visited[row][col+1])
　　　{ s->row=row;s->col=col+1; return 1;}
　　　if (W[row][col-1]=(-1)*tag)&&(!visited[row][col-1])
　　　{ s->row=row;s->col=col-1; return 1}
　　　（5）;
　　}

答案：
（1）strlen(s)+strlen(t) （2）position+strlen(t) （3）target[i]=s[i-strlen(t)]
（4）return a （5）return f(a,b-a)
（6）q=aveage(head->next)　　（7）p->ave=(head->data+q->ave*q->num)/p->num
（1）j<d[i] （2）data,d[i],j,n　（3）num+i*d<n　　（4）data[j+i*d]<temp　　（5）data[j]=temp
（1）q[rear]=T （2）front<p （3）q[rear]=T->lchild （4）count++ （5）flag<count
（1）count （2）(x[i]>end[j])&&(x[i]-start[j]<=1) （3）start[j]=x[i] （4）!flag （5）
（1）visited[i][j]=0 （2）flag　　（3）flag=search(s,tag) （4）s=gettop(S)　（5）return 0


　 课已全部授完,也该收笔了.望对大家有所启发吧!