数据结构题集C语言版答案_严蔚敏吴+伟民

void Descend(int &x, int &y, int &z)

{

int t;

if(x

if(y

}

Status Fibonacci(int k, int m, int &f)

/* 求k阶斐波那契序列的第m项的值f */

{

int i,j,sum,temp[20];

if(k<2||m<0) return ERROR;

if(m

else if(m==k-1) f=1;

else

{for(i=0;i<=k-2;i++)

temp[i]=0;

temp[k-1]=1;

for(i=k;i<=m;i++)

{sum=0;

for(j=i-k;j

sum+=temp[j];

temp[i]=sum;

}

f=temp[m];

}

return OK;

}// Fibonacci

void Scores(ResultType *result, ScoreType *score)

/* 求各校的男、女总分和团体总分, 并依次存入数组score */ /* 假设比赛结果已经储存在result[ ]数组中, */

/* 并以特殊记录{"", male, ' ', "", 0 }（域scorce=0）*/

/* 表示结束*/ {

int i=0;

while(result[i].sport!=NULL)

{

switch(result[i].schoolname)

{

case 'A':

score[0].totalscore+=result[i].score;

if(result[i].gender==male) score[0].malescore+=result[i].score;

else score[0].femalescore+=result[i].score;

break;

case 'B':

score[1].totalscore+=result[i].score;

if(result[i].gender==male) score[1].malescore+=result[i].score;

else score[1].femalescore+=result[i].score;

break;

case 'C':

score[2].totalscore+=result[i].score;

if(result[i].gender==male) score[2].malescore+=result[i].score;

else score[2].femalescore+=result[i].score;

break;

case 'D':

score[3].totalscore+=result[i].score;

if(result[i].gender==male) score[3].malescore+=result[i].score;

else score[3].femalescore+=result[i].score;

break;

case 'E':

score[4].totalscore+=result[i].score;

if(result[i].gender==male) score[4].malescore+=result[i].score;

else score[4].femalescore+=result[i].score;

break;

}

i++;

}

for(s='A';s<='E';s++)

{

printf("School %c:\n",s);

printf("Total score of male:%d\n",score[i].malescore);

printf("Total score of female:%d\n",score[i].femalescore);

printf("Total score of all:%d\n\n",score[i].totalscore);

}

Status Series(int ARRSIZE, int a[])

/* 求i!*2^i序列的值并依次存入长度为ARRSIZE的数组a； */ /* 若所有值均不超过MAXINT，则返回OK，否则返回OVERFLOW */ {

int last,i;

last=1;

for (i=1;i<=ARRSIZE;i++)

{

a[i-1]=last*2*i;

if (a[i-1]>MAXINT)

return OVERFLOW;

last=a[i-1];

}

return OK;

}

float Polynomial(int n, int a[], float x)

/* 求一元多项式的值P(x)。 */

/* 数组a的元素a[i]为i次项的系数，i=0,...,n */

{

int j,i;

float y,s;

y=0;

for(j=n;j>0;j--)

y=x*(y+a[j]);

s=y+a[0];

return(s);

}

第二章

char Compare(SqList A, SqList B)

// 比较顺序表A和B,

// 返回'<', 若A

// '=', 若A=B;

// '>', 若A>B

{

int i;

for(i=1;i<=A.length&&i<=B.length;i++)

if(A.elem[i]!=B.elem[i])

return A.elem[i]>B.elem[i]?'>':'<';

if(A.length==B.length) return '=';

return A.length>B.length?'>':'<';

}

int Length(LinkList L)

// Return the length of the linked list

// whose head node is pointed by 'L'

{

LNode *p;

int k;

p=L;

for(k=0;(p->next)!=NULL;p=p->next,k++);

return k;

}

void DeleteSome(LinkList &L, ElemType mink, ElemType maxk)

/* Delete all the elements which value is between mink and */ /* maxk from the single sorted LinkList with head pointer L.*/ {

LinkList p,q,pre;

pre=L;

while(pre->next&&pre->next->data<=mink)

pre=pre->next;

p=pre->next;

while(p&&p->data

{

q=p;

p=p->next;

free(q);

}

pre->next=p;

}

void Inverse(SqList &L)

{

int i,j;

ElemType p;

for(i=0,j=L.length-1;i

{

p=L.elem[j];

L.elem[j]=L.elem[i];

L.elem[i]= p;

}

void Inverse(LinkList &L)

/* 对带头结点的单链表L实现就地逆置 */

{

LinkList p,q,s;

p=L->next;

q=p->next;

if(p->next!=NULL&&q->next!=NULL)

{

s=q->next;p->next=NULL;

while(s->next)

{

q->next=p;p=q;q=s;s=s->next;

}

q->next=p;s->next=q;L->next=s;

}

ElemType DeleteNode(LinkList s)

/* 删除指针s所指结点的前驱结点，并返回被删结点的元素值 */ { LNode *p;

int e;

p=s;

while(p->next->next!=s)

p=p->next;

e=p->next->data;

p->next=s;

return e;

}

void Difference(LinkedPoly &pa)

/* 稀疏多项式 pa 以循环链表作存储结构， */

/* 将此链表修改成它的导函数，并释放无用结点 */

{

LinkedPoly p,q,t;

p=pa->next;

t=pa;

while(p!=pa)

{

if(p->exp==0)

{

q=p;

p=q->next;

t->next=p;

free(q);

}

p->coef*=p->exp;

p->exp--;

t=p;

p=p->next;

}

LinkList Locate(LinkList &L, ElemType x)

// If 'x' in the linked list whose head node is pointed

// by 'L', then return pointer ha pointing node 'x',

// otherwise return 'NULL'

{

LNode*p;

for(p=L->next;p&&p->data!=x;p=p->next);

return p;

}

Status DeleteAndInsertSub(LinkList &la, LinkList &lb,

int i, int j, int len)

// la和lb分别指向两个单链表中第一个结点，*/ /* 本算法是从la表中删去自第i个元素起共len个元素，*/ /* 并将它们插入到lb表中第j个元素之前，*/ /* 若lb表中只有j-1个元素，则插在表尾。*/ {

if(i<=0 || j<=0 || len<=0)

return INFEASIBLE;

LNode *s,*t,*o,*r;

int x=0,y=0,z=1;

s=(LinkList)malloc(sizeof(LNode));

t=(LinkList)malloc(sizeof(LNode));

s->next=la;

t->next=lb;

la=s;

lb=t;

while(s->next!=NULL && x<(i-1))

{

s=s->next;

x++;

}

if(s->next==NULL && x<(i-1)) {

s=la;

t=lb;

la=la->next;

lb=lb->next;

free(s);

free(t);

return INFEASIBLE;

}

r=o=s->next;

while(o!=NULL && z

{

o=o->next;

z++;

}

if(o==NULL || z

{

s=la;

t=lb;

la=la->next;

lb=lb->next;

free(s);

free(t);

return INFEASIBLE;

}

while(t->next!=NULL && y<(j-1)) {

t=t->next;

y++;

}

if(t->next==NULL && y<(j-1)) {

s=la;

t=lb;

la=la->next;

lb=lb->next;

free(s);

free(t);

return INFEASIBLE;

}

s->next=o->next;

o->next=t->next;

t->next=r;

s=la;

t=lb;

la=la->next;

lb=lb->next;

free(s);

free(t);

return OK;

}

void Purge(LinkList &L)

{

LinkList p,t,r;

p=L;

t=p->next;

while(p->next->next!=NULL)

{

p=p->next;

t=t->next;

while(t->next!=NULL && t->data==p->data)

{

r=t;

p->next=t->next;

free(r);

t=t->next;

}

if(t->next==NULL && p->data==t->data)

{r=t;

p->next=t->next;

free(r);

}

void Merge(LinkList ha, LinkList hb, LinkList &hc)

/* 依题意，合并带头结点的单链表ha和hb为hc */ {

LNode*p;

LNode*q;

LNode*s;

LNode*t;

p=ha->next;q=hb->next;hc=ha;

while(p&&q)

{

s=p->next;p->next=q;

if(s)

{

t=q->next;q->next=s;

}

p=s;q=t;

}

void Intersect(LinkList &hc, LinkList ha, LinkList hb)

{

LNode *p,*q,*s,*pc;

pc=hc;

p=ha->next;q=hb->next;

while(p&&q)

{

if(p->datadata) p=p->next;

else if(p->data>q->data) q=q->next;

else

{

s=(LNode*)malloc(sizeof(LNode));

s->data=p->data;

pc->next=s;pc=s;

p=p->next;q=q->next;

}

void PerfectBiLink(BiLinkList &CL)

{

BiNode*p;

for(p=CL;!p->next->prev;p=p->next)

p->next->prev=p;

}

void Split(LinkList &lc, LinkList &ld, LinkList &lo, LinkList ll)

{

LNode *p,*q,*r,*s;

s=ll->next;

lc=(LinkList)malloc(sizeof(LNode));p=lc;

ld=(LinkList)malloc(sizeof(LNode));q=ld;

lo=(LinkList)malloc(sizeof(LNode));r=lo; //建立头结点

while(s)

{

if((s->data>='A'&&s->data<='Z')||(s->data>='a'&&s->data<='z')) {

p->next=s;p=s;

}

else if(s->data>='0'&&s->data<='9')

{

q->next=s;q=s;

}

else

{

r->next=s;r=s;

}

s=s->next;

}

p->next=lc;q->next=ld;r->next=lo;

}

void ReverseEven(BiLinkList &L)

{

BiNode *p;

p=L->next;

if(p->next==L)

{

p->prev=L;L->prev=p;

}

else{

while(p->next!=L&&p->next->next!=L)

{

p->next=p->next->next;

p=p->next;

}

if(p->next==L)

p->next=L->prev->prev;

else p->next=L->prev;

p=p->next;

while(p->prev->prev!=L)

{

p->next=p->prev->prev;

p=p->next;

}

p->next=L;

for(p=L;p->next!=L;p=p->next)

p->next->prev=p;

L->prev=p;

}

float Evaluate(SqPoly pn, float x)

/* pn.data[i].coef 存放ai，*/

/* pn.data[i].exp存放ei (i=1,2,...,m) */

/* 本算法计算并返回多项式的值。不判别溢出。*/

/* 入口时要求0≤e1

{

PolyTerm *q;

float xp,sum;

xp=1;q=pn.data;

sum=0;

int ex=0;

while(q->coef!=NULL)

{

while(exexp)

{xp*=x;

ex++;}

sum+=q->coef*xp;

q++;

}

return sum;

}

第三章

Status InitStack(TwoWayStack &tws, int size)

{

tws.elem = (SElemType *)malloc( size * sizeof(SElemType) ); if( !tws.elem ) exit(OVERFLOW);

tws.size = size;

tws.top[0] = 0;

tws.top[1] = size - 1;

return OK;

}

Status Push(TwoWayStack &tws, int i, SElemType x) {

if( tws.top[0] + 1 > tws.top[1] ) return ERROR; else if( i == 0 )

{

tws.elem[tws.top[0]++] = x;

}

else

{ tws.elem[tws.top[1]--] = x;

}

return OK;

}

Status Pop(TwoWayStack &tws, int i, SElemType &x) { if( i == 0 )

{

if( tws.top[0] == 0 )

return ERROR;

else

{

x = tws.elem[--tws.top[0]];

}

else

{

if( tws.top[1] == tws.size - 1 )

return ERROR;

else

{

x = tws.elem[++tws.top[1]];

}

return OK;

}

void SwitchYard(SqList train, char *s)

/* 顺序表train表示列车，其元素取值H或S， */

/* 分别表示硬席或软席车厢； */

/* 以U和O分别表示入栈和出栈操作； */

/* 函数用参数s以UO串的形式，返回对该列车 */

/* 进行软席在前，硬席在后的编组的操作序列。*/

{ ElemType *p;

int i,count=0,j;

p=train.elem;

while(*p)

{if(*p=='H') {s[i]='U';++count;}

else if(*p=='S') {s[i]='U';s[i+1]='O';i=i+1;}

p++;i++;

}

for(j=1;j<=count;j++)s[i++]='O';

}

Status MatchCheck(SqList exp)

/* 顺序表exp表示表达式； */

/* 若exp中的括号配对，则返回TRUE，否则返回FALSE */

{ SElemType p;

int i;

float j; j=exp.length%2;if(j)return FALSE;

SqStack s;

if(exp.elem[0]==')'|| exp.elem[0]==']'||exp.elem[0]=='}') return FALSE; InitStack(s);

for(i=0;i

{switch(exp.elem[i])

{case '(': {Push(s,exp.elem[i]);break;}

case '[': {Push(s,exp.elem[i]);break;}

case '{': {Push(s,exp.elem[i]);break;}

case ')': {GetTop(s,p);if(p=='(')Pop(s,p);break;}

case ']': {GetTop(s,p);if(p=='[')Pop(s,p);break;}

case '}': {GetTop(s,p);if(p=='{')Pop(s,p);break;}

}

if(StackEmpty(s)) return TRUE;

else return FALSE;

}

char *RPExpression(char *e)

/* 返回表达式e的逆波兰式 */

{ int i;

char *p,c;

p=(char*)malloc(strlen(e)*sizeof(char));

Stack s;

InitStack(s);

for(;*e!='\0';e++)

{ if((*e!='+')&&(*e!='-')&&(*e!='*')&&(*e!='/')&&(*e!='(')&&(*e!=')')) {*(p+i)=*e;

i++;

}

else

{switch(*e)

{case'(':Push(s,*e);break;

case')':while(Top(s)!='(')

{Pop(s,c);

*(p+i)=c;

i++;

}

Pop(s,c);break;

case'+':

case'-':while(!(StackEmpty(s))&&!(Top(s)=='('))

{Pop(s,c);

*(p+i)=c;

i++;

}

Push(s,*e);break;

case'*':

case'/':if((Top(s)=='*'||Top(s)=='/'))

{Pop(s,c);

*(p+i)=c;

i++;

Push(s,*e);

}

else

Push(s,*e);break;

}

while(!(StackEmpty(s)))

{Pop(s,c);

*(p+i)=c;

i++;

}

*(p+i)='\0';

return p;

}

int G(int m, int n)

/* if m<0 or n<0 then return -1. */

{

if(m<0||n<0) return -1;

if(m==0&&n>=0) return 0;

else return (n+ G(m-1,2*n));

}

◆3.28②假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点(注意不设头指针)，试编写相应的队列初始化、入队列和出队列的算法。实现下列函数：

Status InitCLQueue(CLQueue &rear);

Status EnCLQueue(CLQueue &rear, ElemType x); Status DeCLQueue(CLQueue &rear, ElemType &x); Status InitCLQueue(CLQueue &rear)

{ rear=(LNode*)malloc(sizeof(LNode));

if(!rear) return ERROR;

rear->next=rear;

return OK;

}

Status EnCLQueue(CLQueue &rear, ElemType x) { LinkList p;

p=(LNode*)malloc(sizeof(LNode));

if(!p) return ERROR;

p->data=x;

p->next=rear->next;

rear->next=p;

rear=p;

return OK;

}

Status DeCLQueue(CLQueue &rear, ElemType &x) { LinkList p;

if(rear==rear->next) return ERROR;

p=rear->next->next;

x=p->data;

rear->next->next=p->next;

free(p);

return OK;

}

3.29③如果希望循环队列中的元素都能得到利用，

则需设置一个标志域tag，并以tag的值为0或1来区分，尾指针和头指针值相同时的队列状态是"空"还是"满"。试编写与此结构相应的入队列和出队列的

算法，并从时间和空间角度讨论设标志和不设标志

这两种方法的使用范围（比如，当循环队列容量较

小而队列中每个元素占的空间较多时，那一种方法

较好？）。

实现下列函数：

Status EnCQueue(CTagQueue &Q, QElemType x); Status DeCQueue(CTagQueue &Q, QElemType &x);

本题的循环队列CTagQueue的类型定义如下：

typedef char QElemType;

typedef struct {

QElemType elem[MAXQSIZE];

int tag;

int front;

int rear;

} CTagQueue;

Status EnCQueue(CTagQueue &Q, QElemType x)

{

if(Q.tag==1&&Q.front==Q.rear)return ERROR;

Q.elem[Q.rear]=x;

Q.rear=(Q.rear+1)%MAXQSIZE;

if(Q.rear==Q.front)Q.tag=1;

return OK;

}

Status DeCQueue(CTagQueue &Q, QElemType &x) {

if(Q.tag==0&&Q.front==Q.rear)return ERROR; x=Q.elem[Q.front];

Q.front=(Q.front+1+MAXQSIZE)%MAXQSIZE;

if(Q.rear==Q.front)Q.tag=0;

return OK;

}

Status EnCQueue(CLenQueue &Q, QElemType x)

{ if( Q.length == MAXQSIZE )

return ERROR;

Q.rear = (Q.rear + 1) % MAXQSIZE;

Q.elem[Q.rear] = x;

Q.length++;

return OK;

}

Status DeCQueue(CLenQueue &Q, QElemType &x)

{ int len;

if( Q.length == 0 )

return ERROR;

len = (Q.rear - Q.length + 1 + MAXQSIZE) % MAXQSIZE; x = Q.elem[len];

Q.length--;

return OK;

}

Status Palindrome(char *word)

/* 利用栈和队列判定字符序列word是否是回文 */

{ int i = 0;

char x, y;

Stack S;

InitStack( S );

Queue Q;

InitQueue( Q );

while( word[i] != '@' )

{

EnQueue( Q, word[i] );

Push( S, word[i] );

++i;

}

while( !StackEmpty( S ) )

{

DeQueue( Q, x );

Pop( S, y );

if( x != y )

return ERROR;

}

return OK;

void ChangeColor(GTYPE g, int m, int n,

char c, int i0, int j0)

/* 在g[1..m][1..n]中，将元素g[i0][j0] */

/* 所在的同色区域的颜色置换为颜色c */ {int x,y,old;

Stack s;

old=g[i0][j0];

StackInit(s,m*n*2);

Push(s,i0);

Push(s,j0);

while(!StackEmpty(s))

{

Pop(s,y);

Pop(s,x);

if(x>1)

if(g[x-1][y]==old)

{

g[x-1][y]=c;

Push(s,x-1);

Push(s,y);

}

if(y>1)

if(g[x][y-1]==old)

{

g[x][y-1]=c;

Push(s,x);

Push(s,y-1);

}

if(x

if(g[x+1][y]==old)

{

g[x+1][y]=c;

Push(s,x+1);

Push(s,y);

}

if(y

if(g[x][y+1]==old)

{

g[x][y+1]=c;

Push(s,x);

Push(s,y+1);

}

}//while

}

int F(int n)

/* if n<0 then return -1. */

{ if (n<0) return -1;

else if(n==0)return n+1;

else return n*F(n/2);

}

第四章

void Reverse(StringType &s)

/* Reverse s by iteration. */

{

StringType r;

StringType c;

int i;

InitStr(r);

InitStr(c);

for(i= StrLength(s);i>=1;i--)

{

StrAssign(c,SubString(s,i,1));

Concat(r,c );

}

StrAssign(s,r);

}

Void pe &S, StringType T, StringType V)

/* 以串 v 置换串 s 中出现的所有和串 t 相同的非空串 */ { StringType start;

StringType tail;

int i;

for(i=1;i<=StrLength(S)-StrLength(T)+1;i++)

if(!StrCompare(SubString(S,i,StrLength(T)),T))

{

StrAssign(start,SubString(S,1,i-1));

StrAssign(tail,SubString(S,StrLength(T)+i,StrLength(S)-StrLength(T)-i+1)); Concat(start,V);

StrAssign(S,start);

Concat(S,tail);

i-=1;

}

void DelSubString(StringType &scrStr, StringType subStr)

/* Remove all substring matching 'subStr' from 'scrStr'. */

{ int i,a,b;

a=StrLength(scrStr);

b=StrLength(subStr);

StringType h;

StringType t;

InitStr(h);

InitStr(t);

for(i=1;i<=a-b+1;i++)

if(! StrCompare( SubString (scrStr,i,b),subStr))

{

StrAssign(h,SubString(scrStr,1,i-1));

StrAssign(t,SubString(scrStr,i+b,a-b+1-i));

Concat(h,t);

StrAssign (scrStr,h);

i--;

}

Status Replace(SString& s, SString t, SString v)

/* 用串v替换串s中所有和串t匹配的子串。 */