广工数据结构参考答案全(anyview)分析

广工数据结构anyview 80道上机题
1.
void Descend(int &x, int &y, int &z)
/* 按从大到小顺序返回x，y和z的值*/ {
int t;
if(x<z)
{
t=z;
z=x;
x=t;
}
if(y<z)
{
t=y;
y=z;
z=t;
}
if(y>x)
{
t=x;
x=y;
y=t;
}
}
2.
Status Fibonacci(int k, int m, int &f)
/* 求k阶斐波那契序列的第m项的值f */ {
int *a;
int i=1;
if(k<2||m<0) return ERROR;
if(m<k)
{
if(m==k-1) f=1;
else f=0;
return OK;
}
a=(int*)malloc((m+1)*sizeof(int));
for(i=0;i<k-1;i++) a[i]=0;
i=k+1;
a[k-1]=1;
a[k]=1;
while(i<=m)
{
a[i]=2*a[i-1]-a[i-k-1];
i++;
}
f=a[m];
return OK;
}
3.
void Scores(ResultType *result, ScoreType *score)
/* 求各校的男、女总分和团体总分, 并依次存入数组score */
/* 假设比赛结果已经储存在result[ ]数组中, */
/* 并以特殊记录{"", male, ' ', "", 0 }（域scorce=0）*/
/* 表示结束*/
{
int i;
for(i=0;result[i].score!=0;i++)
{
score[result[i].schoolname-'A'].totalscore+=result[i].score;
if(result[i].gender==male)
score[result[i].schoolname-'A'].malescore+=result[i].score;
else
score[result[i].schoolname-'A'].femalescore+=result[i].score;
}
}
4
Status Series(int ARRSIZE, int a[])
/* 求i!*2^i序列的值并依次存入长度为ARRSIZE的数组a；*/
/* 若所有值均不超过MAXINT，则返回OK，否则返回OVERFLOW */
{
int i=1,b=1,na=1;
while(i<=ARRSIZE)
{
na*=i;b*=2;
if(na*b>MAXINT) return OVERFLOW;
a[i-1]=na*b;
i++;
if(i>ARRSIZE+1) return OVERFLOW;
}
return OK;
}
5
float Polynomial(int n, int a[], float x)
/* 求一元多项式的值P(x)。

*/
/* 数组a的元素a[i]为i次项的系数，i=0,...,n */
{
float ans=a[0],t=1.0;
int i=1;
while(i<=n)
{
t*=x;
ans+=(t*a[i]);
i++;
}
return ans;
}
6
void InsertOrderList(SqList &L, ElemType x)
// 在有序的顺序表L 中保序插入数据元素x
{
int i=L.length-1;
while(L.elem[i]>x)
{
L.elem[i+1]=L.elem[i];
i--;
}
L.elem[i+1]=x;
L.length++;
}
7
char Compare(SqList A, SqList B)
// 比较顺序表A和B,
// 返回'<', 若A<B;
// '=', 若A=B;
// '>', 若A>B
{
int i=0;
while(A.elem[i]==B.elem[i]&&i<A.length&&i<B.length) i++;
if(i==A.length&&i==B.length) return '=';
if(A.elem[i]>B.elem[i]||i==B.length) return '>';
return '<';
}
8
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'
{
LinkList p;
p=L->next;//第一个元素
while(p->next!=NULL)
{
if(p->data==x) return p;
p=p->next;
}
return NULL;
}
9
int Length(LinkList L)
// Return the length of the linked list
// whose head node is pointed by 'L'
{
int i=0;
while(L->next!=NULL)
{
i++;
L=L->next;
}
return i;
}
10
void Insert(LinkList &L, int i, ElemType b) {
int j=1;
if(i==0) return ;
LinkList p,q;
q=L;
p=(LinkList)malloc(sizeof(LNode));
p->data=b;
if(i==1)
{
p->next=L;
L=p;
}
else
{
while(j<i-1&&q->next!=NULL)
{
j++;
q=q->next;
}
if(j<i-1) return ;
p->next=q->next;
q->next=p;
}
}
11
void Delete(LinkList &L, int i)
{
int j=1;
LinkList p,q;
p=L;
if(i==0) return ;
if(i==1)
{
L=L->next;
return;
}
while(j<i-1)
{
j++;
p=p->next;
if(p->next==NULL) return;
}
q=p;
p=p->next;
q->next=p->next;
free(p);
}
12
void Purge(LinkList &L)
{
LinkList cur,temp,del;//cur当前结点,temp遍历下一个结点,del删除结点cur=L->next;
temp=cur->next;
if(cur==NULL||temp==NULL) return;//空或者只有一个元素,返回
while(cur->next)
{
temp=cur->next;
while(temp)
{
if(cur->data==temp->data)
{
del=temp;
temp=temp->next;//temp指向下一个元素
cur->next=temp; //删除后连接
free(del);
}
else temp=temp->next;
}
cur=cur->next;
}
}//时间复杂度O(n*n)
13
void Inverse(SqList &L)
{
int i=0;
ElemType t;
while(i<L.length/2)
{
t=L.elem[i];
L.elem[i]=L.elem[L.length-i-1];
L.elem[L.length-i-1]=t;
i++;
}
}
14
void Inverse(LinkList &L)
/* 对带头结点的单链表L实现就地逆置*/
{
LinkList p,q,k;
p=q=L->next;
p=p->next;
L->next->next=NULL;
if(!p) return ;
while(p)
{
k=q;
q=p;
p=p->next;
q->next=k;
}
L->next=q;
}
15
void Merge(LinkList ha, LinkList hb, LinkList &hc)
/* 依题意，合并带头结点的单链表ha和hb为hc */
{
LinkList pa,pb,pc;
hc=ha;
pc=hc;
pa=ha->next;
pb=hb->next;
if(!pa) {hc=hb;return;}
if(!pb) {hc=ha;return;}
while(pa||pb)
{
pc->next=pa;
if(!pb) {return;}
pc=pc->next;
pa=pa->next;
pc->next=pb;
if(!pa) {return;}
pb=pb->next;
pc=pc->next;
}
}
16
void Union(LinkList &lc, LinkList &la, LinkList &lb) {
LinkList pa,pb,pc;
pa=la->next;pb=lb->next; //合并
lc=pc=la;
while(pa&&pb)
{
if(pa->data <= pb->data)
{
pc->next=pa;
pc=pa;
pa=pa->next;
}
else
{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
pc->next=pa ? pa : pb;
pa=pb=lc->next; //逆置
pa=pa->next;
lc->next->next=NULL;
if(!pa) return ;
while(pa)
{
pc=pb;
pb=pa;
pa=pa->next;
pb->next=pc;
}
lc->next=pb;
}
17
ElemType DeleteNode(LinkList s)
/* 删除指针s所指结点的前驱结点，并返回被删结点的元素值*/ {
LinkList p;
ElemType a;
p=s->next;
while(p->next->next!=s) p=p->next;
a=p->next->data;
p->next=s;
return a;
}
18
void PerfectBiLink(BiLinkList &CL)
{
BiLinkList pre,net,t;
pre=t=CL;
net=t->next;
while(net!=t)
{
net->prev=pre;
pre=net;
net=net->next;
}
t->prev=pre;
}
19
void Split(LinkList &lc, LinkList &ld, LinkList &lo, LinkList ll)
{
LinkList itor,pc,pd,po;
itor=ll->next;
lc=(LinkList)malloc(sizeof(LNode));pc=lc;
ld=(LinkList)malloc(sizeof(LNode));pd=ld;
lo=(LinkList)malloc(sizeof(LNode));po=lo;
while(itor)
{
if(itor->data>='a'&&itor->data<='z'||itor->data>='A'&&itor->data<='Z')
{
pc->next=itor;
pc=itor;
}
else if(itor->data<='9'&&itor->data>='0')
{
pd->next=itor;
pd=itor;
}
else
{
po->next=itor;
po=itor;
}
itor=itor->next;
}
pc->next=lc;
pd->next=ld;
po->next=lo;
}
20
void ReverseEven(BiLinkList &L)
{
BiLinkList p1,p2;
p1=L->next;p2=L;
while(p1->next!=L)
{
if(p1->next->next!=L)
{
p1->next=p1->next->next;//接隔一个
p1=p1->next;//去到隔一个处
p2->prev=p1->prev;//p2的前驱为p1前驱
p1->prev=p1->prev->prev;
p2->prev->next=p2;//p1的前驱的后继为p2
p2=p2->prev;//p2去到p2前驱
}
else
{
p2->prev=p1->next;
p1->next->next=p2;
p2=p2->prev;
break;
}
}
p1->next=p2;
p2->prev=p1;
}
21
float Evaluate(SqPoly pn, float x)
/* pn.data[i].coef 存放ai，*/
/* pn.data[i].exp存放ei (i=1,2,...,m) */
/* 本算法计算并返回多项式的值。

不判别溢出。

*/ /* 入口时要求0≤e1<e2<...<em，算法内不对此再作验证*/ {
int i,j;
float ans=0.0,s;
for(i=0;i<pn.length;i++)
{
s=1;
for(j=0;j<pn.data[i].exp;j++) s*=x;
ans+=pn.data[i].coef*s;
}
return ans;
} //O(n*n)
22
void Difference(LinkedPoly &pa)
/* 稀疏多项式pa 以循环链表作存储结构，*/
/* 将此链表修改成它的导函数，并释放无用结点*/
{
PolyLink p;
p=pa->next;
while(p!=pa)
{
if(p->exp==0)
{
pa->next=p->next;
free(p);
p=pa->next;
}
else
{
p->coef *= p->exp;
p->exp--;
p=p->next;
}
}
}
23
Status match(char *str)
/* 若str是属该模式的字符序列，*/
/* 则返回TRUE，否则返回FALSE */
{
Stack s;
InitStack(s);
SElemType e;
int i=0;
while(str[i]!='&')
{
Push(s,str[i]);
i++;
}
i++;
while(str[i]!='@')
{
GetTop(s,e);
if(StackEmpty(s)||e!=str[i]) return FALSE;
Pop(s,e);
i++;
}
if(!StackEmpty(s)) return FALSE;
return TRUE;
}
24
Status MatchCheck(SqList exp)
/* 顺序表exp表示表达式；*/
/* 若exp中的括号配对，则返回TRUE，否则返回FALSE */ /* 注：本函数不使用栈*/ {
int i=0,count=0;
while(i<exp.length)
{
if(exp.elem[i]=='(') count++;
if(exp.elem[i]==')') count--;
if(count<0) return FALSE;
i++;
}
if(!count) return TRUE;
return FALSE;
}
25
Status MatchCheck(SqList exp)
/* 顺序表exp表示表达式；*/
/* 若exp中的括号配对，则返回TRUE，否则返回FALSE */ {
int i=0;
Stack s;
SElemType e;
InitStack(s);
while(i<exp.length)
{
if(exp.elem[i]=='('||exp.elem[i]=='['||exp.elem[i]=='{')
Push(s,exp.elem[i]);
else if(exp.elem[i]==')'||exp.elem[i]==']'||exp.elem[i]=='}')
{
if(StackEmpty(s)) return FALSE;
else
{
GetTop(s,e);
switch(exp.elem[i])
{
case ')':
if(e=='(') {Pop(s,e); break;}
else return FALSE;
case ']':
if(e=='[') {Pop(s,e); break;}
else return FALSE;
case '}':
if(e=='{') {Pop(s,e); break;}
else return FALSE;
default: break;
}
}
}
i++;
}
if(StackEmpty(s)) return TRUE;
return FALSE;
}
26
void ChangeColor(GTYPE g, int m, int n,
char c, int i0, int j0)
/* 在g[1..m][1..n]中，将元素g[i0][j0] */
/* 所在的同色区域的颜色置换为颜色c */
{
char color=g[i0][j0];
g[i0][j0]=c;
int dx[4]={-1,+1,0,0},dy[4]={0,0,-1,+1},i;
for(i=0;i<4;i++)
{
if(i0+dx[i]<=m&&j0+dy[i]<=n&&j0+dy[i]>=1&&i0+dx[i]>=1&&g[i0+dx[i]][j0+dy[i]]==color) ChangeColor(g,m,n,c,i0+dx[i],j0+dy[i]);
}
}
27
char *RPExpression(char *e)
/* 返回表达式e的逆波兰式*/
{
int i,j=0;
char *str;
str=(char*)malloc(30*sizeof(char));
SElemType e1;
Stack so;
for(i=0;e[i]!='\0';i++)
{
if(e[i]<='9'&&e[i]>='0'||e[i]>='a'&&e[i]<='z'||e[i]>='A'&&e[i]<='Z')//入数字栈
{
str[j++]=e[i];
}
else
{
if(e[i]=='('||e[i]=='['||StackEmpty(so))//入栈
Push(so,e[i]);
else if(e[i]==')')
{
while(Top(so)!='(')//将()内的操作符做运算
{
str[j++]=Top(so);//操作符入栈
Pop(so,e1);
}
Pop(so,e1);
}
else if(e[i]==']')
{
while(Top(so)!='[')
{
str[j++]=Top(so);
Pop(so,e1);
}
Pop(so,e1);
}
else if(e[i]=='+'||e[i]=='-')
{
while(Top(so)=='*'||Top(so)=='/'||Top(so)=='+'||Top(so)=='-')//优先计算
{
str[j++]=Top(so);
Pop(so,e1);
}
Push(so,e[i]);
}
else if(e[i]=='*'||e[i]=='/')
{
while(Top(so)=='*'||Top(so)=='/')
{
str[j++]=Top(so);
Pop(so,e1);
}
Push(so,e[i]);
}
}
}
while(!StackEmpty(so))
{
str[j++]=Top(so);
Pop(so,e1);
}
str[j]='\0';
return str;
}
28
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;
if(m>0&&n>=0) return G(m-1,2*n)+n;
}
29
int F(int n)
/* if n<0 then return -1. */
{
if(n<0) return -1;
if(n==0) return n+1;
if(n>0) return n*F(n/2);
}
30
Status InitCLQueue(CLQueue &rear)
{
rear=(LinkList)malloc(sizeof(LNode));
if(!rear) exit(0);
rear->next=rear;
return 1;
}
Status EnCLQueue(CLQueue &rear, ElemType x) {
LinkList p;
p=(LinkList)malloc(sizeof(LNode));
if(!p) exit(0);
p->data=x;
p->next=rear->next;
rear->next=p;
rear=p;
return 1;
}
Status DeCLQueue(CLQueue &rear, ElemType &x) {
LinkList p;
p=(LinkList)malloc(sizeof(LNode));
if(!p) exit(0);
if(rear==rear->next) return 0;
p=rear->next->next;
x=p->data;
rear->next->next=p->next;
free(p);
return 1;
}
31
Status EnCQueue(CTagQueue &Q, QElemType x) {
if(Q.front==Q.rear&&Q.tag) return 0;
Q.elem[Q.rear]=x;
Q.rear=(Q.rear+1)%MAXSIZE;
return 1;
}
Status DeCQueue(CTagQueue &Q, QElemType &x)
{
if(Q.front==Q.rear&&!Q.tag) return 0;
x=Q.elem[Q.front];
Q.front=(Q.front+1)%MAXSIZE;
return 1;
}
32
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 1;
}
Status DeCQueue(CLenQueue &Q, QElemType &x)
{
if(Q.length==0) return ERROR;
x=Q.elem[(MAXQSIZE+Q.rear-Q.length+1)%MAXQSIZE];
Q.length--;
return 1;
}
33
Status Palindrome(char *word)
/* 利用栈和队列判定字符序列word是否是回文*/
{
Stack s;
Queue que;
InitStack(s);InitStack(que);
char a,b;
int i=0;
while(word[i]!='@')
{
Push(s,word[i]);
EnQueue(que,word[i]);
i++;
}
while(!StackEmpty(s)&&!QueueEmpty(que))
{
Pop(s,a);
DeQueue(que,b);
if(a!=b) return ERROR;
}
return 1;
}
35
void Replace(StringType &S, StringType T, StringType V)
/* 以串v 置换串s 中出现的所有和串t 相同的非空串*/
{
int i=1;
StringType st,ss,sm;
InitStr(st);InitStr(ss);InitStr(sm);
while(i<=StrLength(S))
{
ss=SubString(S,i,StrLength(T));
if(StrCompare(ss,T)==0)
{//剪断再接合
sm=SubString(S,1,i-1); //前半段
st=SubString(S,i+StrLength(T),StrLength(S)-i);//后半段
StrAssign(S,sm);
Concat(S,V);
Concat(S,st); //接完后还原S
i+=StrLength(V)-1;//i移动到I+V的距离
}
else i++;
}
}
36
void DelSubString(StringType &scrStr, StringType subStr)
/* Remove all substring matching 'subStr' from 'scrStr'. */
{
int i=1;
StringType sp,sn,st;
InitStr(sp);InitStr(sn);InitStr(st);
while(i<=StrLength(scrStr))
{
st=SubString(scrStr,i,StrLength(subStr));
if(StrCompare(st,subStr)==0)
{
sp=SubString(scrStr,1,i-1);//前半段
sn=SubString(scrStr,i+StrLength(subStr),StrLength(scrStr)-i);//后半段
StrAssign(scrStr,sp);
Concat(scrStr,sn);
i--;
}
i++;
}
}
37
Status Replace(SString& s, SString t, SString v)
/* 用串v替换串s中所有和串t匹配的子串。

*/
/* 若有与t匹配的子串被替换，则返回TRUE；*/
/* 否则返回FALSE */
{
int i=1,j,tot=0,k=0;
SString str;
while(i<=s[0])
{
j=1;
while(j<=t[0])
{
if(t[j]!=s[i+j-1]) break;
j++;
}
if(j>t[0])
{
tot=1;
for(j=1;j<=v[0];j++) str[++k]=v[j];
i=i+t[0];
}
else
{
str[++k]=s[i];
i++;
}
}
for(i=1;i<=k;i++) s[i]=str[i];
s[0]=k;
if(tot) return TRUE;
return FALSE;
}
38
Status DelSub(SString &s, SString t)
/* 从串s中删除所有和串t匹配的子串。

*/
/* 若有与t匹配的子串被删除，则返回TRUE；*/
/* 否则返回FALSE */
{
int i=1,j,tot=0;
while(i<=s[0])
{
j=1;
while(j<=t[0])
{
if(s[i+j-1]!=t[j]) break;
j++;
}
if(j>t[0])
{
tot=1;
for(j=i+t[0];j<=s[0];j++) s[j-t[0]]=s[j];
s[j-t[0]]='\0';
s[0]-=t[0];
}
else i++;
}
if(tot) return TRUE;
return FALSE;
}
39
Status Concat(HString &S, HString S1, HString S2)
/* 用S返回由S1和S2联接而成的新串*/
{
int i;
if(S.ch) free(S.ch);
S.ch=(char*)realloc(S.ch,(S1.length+S2.length)*sizeof(char));
for(i=0;i<S1.length;i++) S.ch[i]=S1.ch[i];
for(i=0;i<S2.length;i++) S.ch[i+S1.length]=S2.ch[i];
S.length=S1.length+S2.length;
return OK;
}
40
void CommonStr(SString s, SString &sub, int &loc)
/* 求串s中出现的第一个最长重复子串sub及其位置loc */ {
int i,j,sum=0,ans=0;
loc=0;
for(i=1;i<=s[0];i++)
for(j=i+1;j<=s[0];j++)
{
if(s[i]==s[j])
{
sum=1;
while(s[i+sum]==s[j+sum]) sum++;
if(ans<sum)
{
ans=sum;
loc=i;
}
}
}
for(i=1;i<=ans;i++)
sub[i]=s[loc+i-1];
sub[0]=ans;
} //O(n*n)
34
void Reverse(StringType &s)
/* Reverse s by iteration. */
{
StringType st;
InitStr(st);
int i,len;
len=StrLength(s);
for(i=len;i>0;i--) Concat(st,SubString(s,i,1));
StrAssign(s,st);
}
广工数据结构80道上机题仅供参考
最后缺了几题
41
void swap(ElemType &a,ElemType &b)
{
ElemType t;
t=a;
a=b;
b=t;
}
void Rotate(Array1D &a, int n, int k)
/* a[n] contains the elements, */
/* rotate them right circlely by k sits */
{
int j,l;
k=n-k%n-1;
for(j=0,l=k;j<l;j++,l--)//前半段
{
swap(a[j],a[k-j]);
}
for(j=k+1,l=n-1;j<l;j++,l--)//后半段
{
swap(a[j],a[l]);
}
for(j=0,l=n-1;j<l;j++,l--)//全部逆转
{
swap(a[j],a[l]);
}
}
42
Status AddTSM(TSMatrix A,TSMatrix B,TSMatrix &C)
/* 三元组表示的稀疏矩阵加法: C=A+B */
{
if(A.mu!=B.mu||A.nu!=B.nu) return 0;
ElemType t;
int i=1,j=1,k=1;
C.mu=A.mu,C.nu=A.nu,C.tu=0;
while(i<=A.tu&&j<=B.tu)
{
if((A.data[i].i==B.data[j].i)&&(A.data[i].j==B.data[j].j))//相等
{
t=A.data[i].e+B.data[j].e;
if(t) //不为0
{
C.data[k].i=A.data[i].i;
C.data[k].j=A.data[i].j;
C.data[k].e=t;
k++;
}
i++;j++;
}
else if((A.data[i].i>B.data[j].i)||(A.data[i].i==B.data[j].i&&A.data[i].j>B.data[j].j))//A 中元素位置大于B中
{
C.data[k].i=B.data[j].i;
C.data[k].j=B.data[j].j;
C.data[k].e=B.data[j].e;
k++;j++;
}
else//A中位置小于B
{
C.data[k].i=A.data[i].i;
C.data[k].j=A.data[i].j;
C.data[k].e=A.data[i].e;
k++;i++;
}
}
while(i<=A.tu)
{
C.data[k].i=A.data[i].i;
C.data[k].j=A.data[i].j;
C.data[k].e=A.data[i].e;
k++;i++;
}
while(j<=B.tu)
{
C.data[k].i=B.data[j].i;
C.data[k].j=B.data[j].j;
C.data[k].e=B.data[j].e;
k++;j++;
}
C.tu=k-1;
return 1;
}
43
Status GetElem(T2SMatrix M, int i, int j, ElemType &e)
/* 求二元组矩阵的元素A[i][j]的值e */
{
int k=M.cpot[i];
if(i>M.mu||i<1||j>M.nu||j<1) return ERROR;//越界..
e=0;
while(k<M.cpot[i+1])//直到下一行的第一个非零元
{
if(M.data[k].j==j)
e=M.data[k].e;
k++;
}
return OK;
}
44
void OutCSM(CrossList M, void(*Out3)(int, int, int))
/* 用函数Out3,依次以三元组格式输出十字链表表示的矩阵*/
{
int i=0;
OLink p;
while(i<=M.mu)
{
if(M.rhead[i])
{
p=M.rhead[i];
while(p)
{
Out3(p->i,p->j,p->e);
p=p->right;
}
}
i++;
}
}
45
int GListDepth(GList ls)
/* Return the depth of list */
{
int max,dep;
GList p;
if(!ls) return 1;
if(ls->tag==0) return 0;
for(max=0,p=ls;p;p=p->un.ptr.tp)
{
dep=GListDepth(p->un.ptr.hp);
max=max>dep?max:dep;
}
return max+1;
}
46
Status Equal(GList A, GList B)
/* 判断广义表A和B是否相等,是则返回TRUE,否则返回FALSE */
{
if(!A&&!B) return TRUE;
if(!A->tag&&!B->tag&&A->un.atom==B->un.atom) return TRUE;//原子时比较if(A->tag&&B->tag)//不是原子,子表递归
{
if(Equal(A->un.ptr.hp,B->un.ptr.hp)&&Equal(A->un.ptr.tp,B->un.ptr.tp))
return TRUE;
}
return FALSE;
}
47
void OutAtom(GList A, int layer, void(*Out2)(char, int))
/* 递归地用函数Out2输出广义表的原子及其所在层次,layer表示当前层次*/ {
if(!A) return ;
if(!A->tag) Out2(A->un.atom,layer);
else
{
OutAtom(A->un.ptr.hp,layer+1,Out2);
OutAtom(A->un.ptr.tp,layer,Out2);
}
}
48
Status Dencendant(Array1D L,Array1D R,int n,int u,int v)
/* If node 'u' is the dencendant of node 'v', */
/* then return 'TRUE' else return 'FALSE'. */
/* L[i] is the left child of the i_th node, */
/* R[i] is the right child of the i_th node */
/* in the Binary Tree which has n nodes. */
{
if(u<=0||u>n) return FALSE;
if(u==L[v]||u==R[v]) return TRUE;
while(L[v])
if(Dencendant(L,R,n,u,L[v])) return TRUE;
while(R[v])
if(Dencendant(L,R,n,u,R[v])) return TRUE;
return FALSE;
}
49
Status Dencend(Array1D L, Array1D R, int n, int u, int v, Array1D T)
/******************************************************************/ {
int i;
if(u>n||u<=0) return FALSE;
T[1]=0;
for(i=1;i<=n;i++)
{
if(L[i]) T[L[i]]=i;
if(R[i]) T[R[i]]=i;
}
while(T[u])
{
if(T[u]==v) return TRUE;
u=T[u];
}
return FALSE;
}
50
Status Similar(BiTree t1, BiTree t2)
/* 判断两棵二叉树是否相似的递归算法*/
{
if(!t1&&!t2) return TRUE;
if((!t1->lchild&&t2->lchild)||(t1->rchild&&!t2->rchild)) return FALSE;
if(Similar(t1->lchild,t2->lchild)&&Similar(t1->rchild,t2->rchild)) return TRUE;
return FALSE;
}
51
void PreOrder(BiTree bt, void (*visit)(TElemType))
/* 使用栈，非递归先序遍历二叉树bt，*/
/* 对每个结点的元素域data调用函数visit */
{
Stack s;
BiTree p=bt;
InitStack(s);
while(p||!StackEmpty(s))
{
if(p)
{
visit(p->data);//访问根节点
Push(s,p);
p=p->lchild;
}
else
{
Pop(s,p);
p=p->rchild;//右孩子
}
}
}
52
void PostOrder(BiTree bt, void (*visit)(TElemType))
/* 使用栈，非递归后序遍历二叉树bt，*/ /* 对每个结点的元素域data调用函数visit */ {
Stack s;
SElemType p,q;
p.ptr=bt;
InitStack(s);
Push(s,p);//根节点入栈
p.tag=0;
while(!StackEmpty(s))
{
Pop(s,p);//顶点元素出栈
if(p.tag) visit(p.ptr->data);//可访问
else
{
p.tag=1;
Push(s,p);//root入栈
q=p;
if(p.ptr->rchild)
{
q.ptr=p.ptr->rchild;
q.tag=0;
Push(s,q);//右孩子入栈
}
q=p;
if(p.ptr->lchild)
{
q.ptr=p.ptr->lchild;
q.tag=0;
Push(s,q);//左孩子入栈
}
}
}
}
53
TElemType ans;
TElemType f(BiTree bt, int &k)
{
if(bt&&k==1) return bt->data;
else
{
if(bt->lchild)
{k--;ans=f(bt->lchild,k);}//遍历zuo
if(bt->rchild)
{k--;ans=f(bt->rchild,k);}//遍历右
return ans;
}
}
TElemType PreOrder(BiTree bt, int k)
/* bt is the root node of a binary linked list, */
/* Preorder travel it and find the node whose */ /* position number is k, and return its value. */ /* if can't found it, then return '#'. */ {
ans='#';
if(k&&bt)
ans=f(bt,k);
return ans;
}
54
int ans=0;//全局变量
void f(BiTree bt, int &x);
void Leaves(BiTree bt, int &x)
/* Count the leaf node of the BiTree */
/* whose root node is bt to x. */
{
ans=0;
if(!bt->lchild&&!bt->rchild) x=0;
else f(bt,x);
}
void f(BiTree bt, int &x)//求叶子数目
{
if(!bt->lchild&&!bt->rchild) ans++;
else if(!bt->lchild) f(bt->rchild,x);//左为空
else if(!bt->rchild) f(bt->lchild,x);//右为空
else//都不空
{
f(bt->rchild,x);
f(bt->lchild,x);
}
x=x>ans?x:ans;
}
55
void Exchange(BiTree &bt)
/* Exchange the left and right leaves of */
/* bitree whose root node is bt */ {
BiTree t;
if(bt)//不空则交换左右孩子
{
t=bt->lchild;
bt->lchild=bt->rchild;
bt->rchild=t;
Exchange(bt->lchild);//遍历左孩子
Exchange(bt->rchild);//右
}
}
56
int ans=0;
int dep(BiTree T)//求子树深度
{
int ld,rd;
if(!T) return 0;
else
{
ld=dep(T->lchild);
rd=dep(T->rchild);
}
return (ld>rd?ld:rd)+1;
}
int Depthx(BiTree T, TElemType x)
/* 求二叉树中以值为x的结点为根的子树深度*/
{
if(T->data==x)//找到结点计算高度
{
ans=dep(T);
return ans;
}
else
{
if(T)
{
if(Depthx(T->lchild,x)||Depthx(T->rchild,x)) return ans;//找到则返回结果
else return 0;//找不到返回0
}
}
}
57
void CopyBiTree(BiTree T, BiTree &TT)
/* 基于层次遍历的非递归复制二叉链表*/
{
Queue q,cq;
BiTree t;
QElemType e,ce;
if(!T)
{
TT=NULL;
return;
}
InitQueue(q);
InitQueue(cq);//复制树队列
TT=(BiTree)malloc(sizeof(BiTNode));
TT->data=T->data;//复制根结点
TT->lchild=NULL;TT->rchild=NULL;
EnQueue(cq,TT);
EnQueue(q,T);//根入队
while(!QueueEmpty(q))
{
DeQueue(q,e);
DeQueue(cq,ce);
if(e->lchild)//复制左
{
t=(BiTree)malloc(sizeof(BiTNode));
t->data=e->lchild->data;
t->lchild=NULL;t->rchild=NULL;
ce->lchild=t;
EnQueue(q,e->lchild);//左孩子入队
EnQueue(cq,ce->lchild);
}
if(e->rchild)//复制右
{
t=(BiTree)malloc(sizeof(BiTNode));
t->data=e->rchild->data;
t->lchild=NULL;t->rchild=NULL;
ce->rchild=t;
EnQueue(q,e->rchild); //右孩子入队
EnQueue(cq,ce->rchild);
}
}
}
58
void LevelOrder(BiTree bt, char *ss)
/* travel BiTree bt by level, Return result by ss. */ {
if(!bt)
{
ss="";
return;
}
int i=0;
Queue q;
QElemType e;
InitQueue(q);
EnQueue(q,bt);//根入队
ss[i++]=bt->data;
while(!QueueEmpty(q))
{
DeQueue(q,e);
if(e->lchild)
{
ss[i++]=e->lchild->data;
EnQueue(q,e->lchild);//左孩子入队}
if(e->rchild)
{
ss[i++]=e->rchild->data;
EnQueue(q,e->rchild);//右孩子入队}
}
ss[i]='\0';
}
59
Status CompleteBiTree(BiTree bt)
/* judge if the binary tree whose root is bt */
/* is a complete tree. */ {
if(!bt) return TRUE;
int i=0;
Queue q;
QElemType e;
InitQueue(q);
EnQueue(q,bt);//根入队
while(!QueueEmpty(q))
{
DeQueue(q,e);
if(!e) i=1;//已经到最后
else if(i) return FALSE;//不是完全二叉树
else
{
EnQueue(q,e->lchild);//左孩子入队
EnQueue(q,e->rchild);//右孩子入队
}
}
return TRUE;
}
60
int find(char c,char *pre,int pos)
{
int i;
for(i=pos;pre[i]!='\0';i++)
if(c==pre[i]) return i;
return i;
}
void BuildBiTree(BiTree &bt, int ps, char *pre,
int is, char *ino, int n)
/* 当前要建立的子树bt的元素总数为n，*/
/* 元素在前序序列pre的起始位置为ps，*/
/* 元素在中序序列ino的起始位置为is */
{
int m,llen,rlen;
if(n<=0) bt=NULL;
else
{
bt=(BiTree)malloc(sizeof(BiTNode));
bt->data=pre[ps];//创建结点,pre数组中
m=find(pre[ps],ino,is);//在pre中从is起找与pre[ps]相同的元素位置
llen=m-is;//以m为根,左边个数
rlen=n-llen-1;//右边元素个数
BuildBiTree(bt->lchild,ps+1,pre,is,ino,llen);//构造左边
BuildBiTree(bt->rchild,ps+llen+1,pre,m+1,ino,rlen);//右边}
}
61
Status DfsReachable(ALGraph g, int i, int j)
/* Judge if it exists a path from vertex 'i' to */
/* vertex 'j' in digraph 'g'. */
/* Array 'visited[]' has been initialed to 'false'.*/
{
ArcNode *p;
visited[i]=TRUE;
for(p=g.vertices[i].firstarc;p;p=p->nextarc)
{
if(p)
{
if(p->adjvex==j) return TRUE;
if(!visited[p->adjvex])
if(DfsReachable(g,p->adjvex,j)) return TRUE;
}
}
return FALSE;
}
62
Status BfsReachable(ALGraph g, int i, int j)
/* Determine whether it exists path from vertex i to */
/* vertex j in digraph g with Breadth_First Search. */
/* Array 'visited' has been initialed to 'false'. */
{
Queue q;
int t;
ArcNode *p;
InitQueue(q);
EnQueue(q,i);
while(!QueueEmpty(q))
{
DeQueue(q,t);
visited[t]=TRUE;//标志走过
for(p=g.vertices[t].firstarc;p;p=p->nextarc)
{
if(p->adjvex==j) return TRUE;//存在路径
if(!visited[p->adjvex]) EnQueue(q,p->adjvex);
}
}
return FALSE;
}
63
void Traverse(Graph dig, V ertexType v0, void (*visit)(VertexType)) /* Travel the digraph 'dig' with Depth_First Search. */
{
int i,w;
if(dig.vexnum==0) return ;
for(i=0;i<dig.vexnum;i++) visited[i]=0;
SStack s;
InitStack(s);
Push(s,v0);
while(!StackEmpty(s))
{
GetTop(s,v0);//取栈顶元素
i=LocateVex(dig,v0);//v0的位置
if(!visited[i])
{
visited[i]=1;
visit(v0);
}
for(w=FirstAdjVex(dig,i);w>=0;w=NextAdjVex(dig,i,w))//查找v0的邻接点{
if(!visited[w])//未访问则入栈,取栈顶元素
{
Push(s,GetVex(dig,w));
break;
}
}
if(w<0) Pop(s,v0); //出栈
}
}
64
Status SinglePath(ALGraph g, VertexType sv, VertexType tv, int k, char *sp)
/* Judge whether it exists a path from sv to tv with length k */
/* in graph g, return path using string sp if exists. */
{
int i,j,q;//从sv开始深搜到tv
ArcNode *p;
if(sv==tv&&!k)//两点重合
{
inpath(sp,sv);
return OK;
}
i=LocateVex(g,sv);//找sv的位置
visited[i]=1;
inpath(sp,sv);//sv加入路径
for(p=g.vertices[i].firstarc;p;p=p->nextarc)//遍历i点的邻接点
{
q=p->adjvex;
if(!visited[q])
{
if(SinglePath(g,g.vertices[q].data,tv,k-1,sp)) return OK;//存在路径
else depath(sp,g.vertices[q].data);//从路径中删除
}
}
visited[i]=0;//重置
return FALSE;。