一、把一個(gè)字符串插入到另一個(gè)字符串的某個(gè)位置（指元素個(gè)數(shù)）之后
　　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;
　　}

    二、輾轉(zhuǎn)相除法求兩個(gè)正整數(shù)的最大公約數(shù)

　　int f(int a,int b)
　　{ if (a==b) （4） ; 
　　　else
　　　{ if (a>b) return f(a-b,b); 
　　　　else （5） ;
　　　}
　　}

    三、求一個(gè)鏈表的所有元素的平均值

　　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。其方法是對序列進(jìn)行m趟排序，在第i趟排序中，按增量d[i]把整個(gè)序列分成d[i]個(gè)子序列，并按直接插入排序的方法對每個(gè)子序列進(jìn)行排序。

    希爾排序的程序?yàn)椋?BR>
　　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） }
　　}

    五、求樹的寬度

　　所謂寬度是指在二叉樹的各層上，具有結(jié)點(diǎn)數(shù)最多的那一層上的結(jié)點(diǎn)總數(shù)。本算法是按層次遍歷二叉樹，采用一個(gè)隊(duì)列q，讓根結(jié)點(diǎn)入隊(duì)列，最后出隊(duì)列，若有左右子樹，則左右子樹根結(jié)點(diǎn)入隊(duì)列，如此反復(fù)，直到隊(duì)列為空。

　　int Width(BinTree *T)
　　{ int front=-1,rear=-1; /* 隊(duì)列初始化*／
　　　int flag=0,count=0,p;/*p用于指向樹中層的最右邊的結(jié)點(diǎn)，flag記錄層中結(jié)點(diǎn)數(shù)的最大值。*／
　　　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) /* 當(dāng)前層已遍歷完畢*/
　　　　　{ if( （5） ) flag=count; count=0; //
　　　　　　p=rear; /* p指向下一層最右邊的結(jié)點(diǎn)*/ 
　　　　　}
　　　} 
　　　return(flag);
　　}

    六、區(qū)間覆蓋

　　設(shè)在實(shí)數(shù)軸上有n個(gè)點(diǎn)（x0，x1，……，xn-2，xn-1），現(xiàn)在要求用長度為1的單位閉區(qū)間去覆蓋這n個(gè)點(diǎn)，則需要多少個(gè)單位閉區(qū)間。
　　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]

    七、圍棋中的提子

　　在圍棋比賽中，某一方（假設(shè)為黑方）在棋盤的某個(gè)位置（i，j）下子后，有可能提取對方（白方的一串子）。以W[19][19]表示一個(gè)棋盤，若W[i][j]=0表示在位置（i，j）上沒有子，W[i][j]=1表示該位置上的是黑子，W[i][j]=-1表示該位置上是白子。可以用回溯法實(shí)現(xiàn)提子算法。
下列程序是黑棋（tag=1）下在（i，j）位置后判斷是否可以吃掉某些白子，這些確定可以提掉的白子以一個(gè)線性表表示。

　　問題相應(yīng)的數(shù)據(jù)結(jié)構(gòu)有：

　　#define length 19 /*棋盤大小*/
　　#define max_num 361 /*棋盤中點(diǎn)的數(shù)量*/
　　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]; /*給已搜索到的棋子位置作標(biāo)記，初值為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

上一頁  [1] [2] [3] [4] [5] [6] [7] [8] [9]