2013级DS作业和实验参考答案总汇(1)

DBEACF

//9063ANSWER CODE1 #include using namespace std; struct Binode{ char data; Binode *lchild,*rchild;}; Binode *Great() { Binode *bt;char ch; cin>>ch; if(ch=='#')bt=NULL; else { bt=new Binode; bt->data=ch; bt->lchild=Great(); bt->rchild=Great(); } return bt; }

Binode *copy(Binode *bt) { Binode *bt1; if(bt==NULL) return NULL; else { bt1=new Binode; bt1->data=bt->data; bt1->lchild=copy(bt->lchild); bt1->rchild=copy(bt->rchild); } return bt1; }

void Inorder(Binode *bt1) { if(bt1==NULL) return; else { Inorder(bt1->lchild); cout<data; Inorder(bt1->rchild); } };

int main() { int n; cin>>n; while(n--) { Binode *bt=Great(); Binode *bt1=copy(bt); Inorder(bt1); if(bt1!=NULL)

}

cout<

return 0;

//9063ANSWER CODE2 #include using namespace std;

struct BiNode{ char data; BiNode *lchild, *rchild;}; BiNode *Creat() { BiNode *bt;char ch; cin>>ch; if(ch=='#')bt=NULL; else { bt=new BiNode; bt->data=ch; bt->lchild=Creat(); bt->rchild=Creat(); } return bt; }

void InOrder(BiNode *root) {

if (root==NULL) return; //递归调用的结束条件 else{ InOrder(root->lchild); //中序递归遍历root的左子树 cout<data; InOrder(root->rchild); //中序递归遍历root的右子树 } }

//层序遍历复制二叉树

BiNode * copy_bitree(BiNode * root) { int front=-1,rear=-1,newfront=-1,newrear=-1; BiNode * Q[100],* newQ[100],*oldp,* newp,*newroot;

if(root==NULL ) return NULL;//空二叉树 oldp=root;

newp=new BiNode;

newp->data=oldp->data; newroot=newp;//新二叉树的根指针 Q[++rear]=oldp;//入队

newQ[++newrear]=newp;//入队 while(rear!=front) {

oldp=Q[++front];//出队

newp=newQ[++newfront];//出队

if(oldp->lchild==NULL) newp->lchild=NULL; else {

newp->lchild=new BiNode; newp->lchild->data=oldp->lchild->data; Q[++rear]=oldp->lchild; newQ[++newrear]=newp->lchild; } if(oldp->rchild==NULL) newp->rchild=NULL; else { newp->rchild=new BiNode; newp->rchild->data=oldp->rchild->data; Q[++rear]=oldp->rchild; newQ[++newrear]=newp->rchild; } } return newroot; }

void main() { int n; BiNode * root,*newroot; cin>>n; while(n--) { root=Creat(); newroot=copy_bitree(root); if(newroot==NULL) continue; }

}

InOrder(newroot);//中序遍历新二叉树 cout<

第九次作业：二叉树的高度宽度9057，9067

9057:Tree's Depth

Problem Description

一个名字叫Small Green的同学，很喜欢研究树的问题。某一天，他随意地在纸上乱涂乱画，画出了各不相同的二

叉树，他同时在想：一颗满的二叉树的深度并不难求。但如果要求出一颗二叉树（可能不是满二叉树）的深度，那么该如何求呢？ Input

输入包含多个例子，每个例子的第一行为一个整数n，表示以下有n组数据，每组数据占一行，为扩展二叉树的前序遍历序列（长度小于50，若节点为NULL则用'#'表示，否则用小写字母表示）。 Output

输出该二叉树的深度。 Sample Input 2

abcd####efg#### abcd####efg#h###i##

Sample Output

4 5

//9057ANSWER CODE1 #include using namespace std;

struct BiNode{char data;BiNode *lchild,*rchild;}; BiNode *Creat() { BiNode *p; char ch; cin>>ch; if(ch=='#') return NULL; else { p=new BiNode; p->data=ch; p->lchild=Creat(); p->rchild=Creat(); } return p; }

int Depth(BiNode *bt) { int l,r; if(bt==NULL) return 0; else { l=Depth(bt->lchild); r=Depth(bt->rchild); return (l>=r)?(l+1):(r+1); } }

main() { int n; while(cin>>n) { while(n--) { BiNode *p=Creat(); cout<

//9057ANSWER CODE2 #include using namespace std;

struct BiNode{char data;BiNode *lchild,*rchild;}; int deep;

BiNode *Creat(int i) { BiNode *p; char ch; cin>>ch; if(ch=='#') return NULL;

//9067ANSWER CODE1

#include using namespace std;

struct BiNode{char data;BiNode *lchild,*rchild,*parent;int level;BiNode(){parent=NULL;level=1;}}; class BiTree{ public:

BiTree(){root=Creat(); } ~BiTree(){Release(root);} void PreOrder(){PreOrder(root);} private: BiNode *root; BiNode *Creat(); void PreOrder(BiNode *root); void Release(BiNode *root); };

int W[51]; int main(){ int n,i,max;cin>>n; while(n--){ max=0; for(i=0;i<51;i++) W[i]=0; BiTree bt; bt.PreOrder(); for(i=0;i<51;i++){if(W[i]>max) max=W[i];} cout<

BiNode *BiTree::Creat(){ char ch;BiNode *p; cin>>ch; if(ch=='#') p=NULL; else{ p=new BiNode;p->data=ch; p->lchild=Creat();if(p->lchild){p->lchild->parent=p;} p->rchild=Creat();if(p->rchild){p->rchild->parent=p;} } return p; }

void BiTree::PreOrder(BiNode *root){ if(root==NULL) return; else{ if(root->parent)root->level=root->parent->level+1; W[root->level]=W[root->level]+1; PreOrder(root->lchild); PreOrder(root->rchild); } }

void BiTree::Release(BiNode *root){ if(root!=NULL) { Release(root->lchild); Release(root->rchild); delete root; } }

//9067ANSWER CODE2 #include using namespace std; int sum[100];

struct BiNode{char data;BiNode *lchild,*rchild;}; BiNode* Creat(int i) { BiNode *p;char ch; cin>>ch; if(ch=='#') return NULL; else { p=new BiNode; p->data=ch; sum[i]++; p->lchild=Creat(i+1); p->rchild=Creat(i+1); } return p; }

int main() { int n,i,width;BiNode *root; while(cin>>n) { while(n--) { memset(sum,0,sizeof(sum)); root=Creat(1); width=0; for(i=1;i<100;i++) if(width

第十次作业：图的邻接矩阵及遍历9070，9072，9087

9070:求度最大的顶点编号 Problem Description

设有一无向图G，采用邻接矩阵存储，现要求设计一个函数，用于求图中度数最大的顶点，并输出其对应的存储编号（下标）。（注：度数最大的顶点可能有多个） Input

有多组测试数据，每组数据的第一行表示图的顶点数n和图的边数e（0

度数最大的顶点对应的存储编号（下标），各下标之间用空格隔开。 Sample Input 4 4

ABCD 0 1 0 3 1 2 1 3

Sample Output

1

//9070ANSWER CODE1 #include using namespace std; int main() { int n,e,i,j,degree[20],max,maxi;char V[20]; while(cin>>n>>e>>V) { for(i=0;i>i>>j;degree[i]++;degree[j]++;} max=degree[0];maxi=0; for(i=0;i=max) {max=degree[i];maxi=i;} } for(i=0;i

}

//9070ANSWER CODE2 #include using namespace std; int main() { int n,e,i,j,k,Max,f,degree[20],arc[20][20]; char Vex[20]; while(cin>>n>>e>>Vex) { for(i=0;i>i>>j;arc[i][j]=1;arc[j][i]=1;} Max=0; for(i=0;iMax)Max=degree[i]; } f=0;

for(i=0;i

return 0;

9072:存储网图

Problem Description

}

设有一无向网图，其顶点值为字符型并假设各值互不相等，采用邻接矩阵表示法存储表示。设计一个算法，存储该网图并输出其邻接矩阵。 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0

输出该网图的邻接矩阵，每组输出占n行，每行有n个数据，每两个数据之间用一个空格隔开，若无边用'#'表示。 Sample Input 4 4 ABCD 0 1 4 0 3 3 1 2 6 1 3 8

Sample Output

0 4 # 3 4 0 6 8 # 6 0 # 3 8 # 0

//9072ANSWER CODE1

#include using namespace std; int main() { int n,e,i,j,k,w,arc[20][20];char Vex[20]; while(cin>>n>>e>>Vex) { for (i=0; i

}

cin>>i>>j>>w; arc[i][j]=w; arc[j][i]=w; } for(i=0;ireturn 0;

9087:邻接矩阵遍历

Problem Description

给出一个无向图的各个点之间的邻接关系，输出遍历序列。 Input

有多组数据，每组数据第一行有两个整数n、m,(0

分别输出从标号为1点开始深度和广度优先搜索的序列，每个数之后有一个空格。每个序列分别占一行。 Sample Input 8 9 1 2 1 3 2 4 2 5 3 6 3 7 4 5 4 8 6 7

Sample Output

1 2 4 5 8 3 6 7 1 2 3 4 5 6 7 8

//9087ANSWER CODE1 #include using namespace std;

int n,visited[100],visited2[100],arc[100][100]; void DFS(int v)

{ cout<

void BFS(int v) { int front=-1,rear=-1,Q[100]; cout<

void main() { int m,i,j,k; while(cin>>n>>m) { for (i=1; i<=n; i++) { for (j=1; j<=n; j++)arc[i][j]=0;} for(k=0;k>i>>j;arc[i][j]=arc[j][i]=1;} for(i=1;i<=n;i++) {visited[i]=0;visited2[i]=0;} DFS(1);cout<

}

第十一次作业：图的生成树9076，9077，9088

9076:深度优先生成树 Problem Description

设有一连通无向图，其顶点值为字符型并假设各值互不相等，采用邻接矩阵表示法存储表示。利用DFS算法求其深度优先生成树（从下标0的顶点开始遍历），并在遍历过程中输出深度优先生成树的每一条边。 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0

输出深度优先生成树的每一条边，每组输出占一行，每条边信息之间有一空格，每行最后均有一空格，具体格式见样例。 Sample Input

4 4 ABCD 0 1 0 3 1 2 1 3

Sample Output

(A,B) (B,C) (B,D)

//9076ANSWER CODE1 #include using namespace std;

int n,visited[100],arc[100][100];char vertex[20]; void DFS_spanningTree(int v) { visited[v]=1; for (int j=0; j

void main() { int e,i,j,k; while(cin>>n>>e>>vertex) { for (i=0; i>i>>j;arc[i][j]=arc[j][i]=1;} for(i=0;i

}

9077:广度优先生成树

Problem Description

设有一连通无向图，其顶点值为字符型并假设各值互不相等，采用邻接矩阵表示法存储表示。利用BFS算法求其广度优先生成树（从下标0的顶点开始遍历），并在遍历过程中输出广度优先生成树的每一条边。 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0

输出广度优先生成树的每一条边，每组输出占一行，每条边信息之间有一空格，每行最后均有一空格，具体格式见样例。 Sample Input 4 4 ABCD 0 1 0 3 1 2 1 3

Sample Output

(A,B) (A,D) (B,C)

//9077ANSWER CODE1 #include using namespace std;

int n,visited[100],arc[100][100];char vertex[20]; void BFS_spanningTree(int v) { int front=-1,rear=-1,Q[100];; visited[v]=1;Q[++rear]=v; while (front!=rear) { v=Q[++front]; for (int j=0; j

void main() { int e,i,j,k; while(cin>>n>>e>>vertex) { for (i=0; i>i>>j;arc[i][j]=arc[j][i]=1;} for(i=0;i

9088:村村相连

Problem Description

漳州市政府调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。市政府的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度

为最小。请计算最小的公路总长度。 Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N(N<100)和M；随后的M行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。 当N、M为0时，输入结束，该用例不被处理。 Output

对每个测试用例，在1行里输出最小的公路总长度，如果未能找到请输出\。 Sample Input 3 3 1 2 1 1 3 2 2 3 4 4 6 1 2 1 1 3 4 1 4 1 2 3 3 2 4 2 3 4 5 0 0

Sample Output

3 5

//9088ANSWER CODE1 #include using namespace std; int n,arc[100][100]; void Prim() {

int i,j,k,count_cc=1;//当count_cc=n时连通，否则不连通输出no found! int length=0;//最小的公路总长度（即最小生成树的代价） int lowcost[100],adjvex[100];

for (i=2; i<=n; i++) //初始化lowcost[]和adjvex[]

{ lowcost[i]=arc[1][i]; adjvex[i]=1; }

lowcost[1]=0; //将顶点0加入集合U中 for (i=2; i<=n; i++) { int weight_min=10000;k=0; for(j=2;j<=n;j++) { if(lowcost[j]!=0 && lowcost[j]!=10000 && lowcost[j]

}

if(lowcost[k]==10000 || k==0) break; count_cc++;

length=length+lowcost[k];

lowcost[k]=0; //将顶点k加入集合U中 for (j=2; j<=n; j++) //调整lowcost和adjvex if (arc[k][j]

void main() { int m,i,j,k,w;; while(cin>>n>>m) { if(n==0) return; for (i=1; i<=n; i++) {for (j=1; j<=n; j++){arc[i][j]=10000;}} for (i=1; i<=n; i++)arc[i][i]=0;

}

for (k=0; k>i>>j>>w; //边依附的两个顶点的序号 arc[i][j]=w; //置有边标志 arc[j][i]=w; } Prim();

第十二次作业：图的最短路径9092，9091，9085

9092:最短路

Problem Description

“水上之都”威尼斯水城是个美丽的地方，ax幻想着某天能够去那里旅游！

一天，ax想到一个问题：

威尼斯由许多n个小岛（由0到n-1编号）以及m座桥梁连成一体！假设ax在s号小岛上，要去t号小岛游玩！那么s到t的最短距离是多少！ Input

本题目包含多组数据，每组数据第一行包含两个正整数n和m(0

再接下一行有两个整数s,t(0<=s,t

}

Output

对于每组数据，请在一行里输出最短距离，如果不存在s到t的路径则输出\。 Sample Input 3 3 0 1 1 0 2 3 1 2 1 0 2 3 1 0 1 1 1 2

Sample Output

2

not found!

//9092ANSWER CODE1 #include using namespace std; int n,arc[200][200];

void Dijk(int v, int v_end)//v源点，v_end终点 { int dist[200],S[200],i,k,num,min; for (i=0; i

while (num

min=10000;k=v;//min为dist[]最小值的下标k

for (i=0; i

for (i=0; idist[k]+arc[k][i]) { dist[i]=dist[k]+arc[k][i]; } } S[num++]= k; //将k加入集合S if(k==v_end && dist[v_end]<10000) {cout<

dist[k]=0; //置k为已生成终点 } cout<<\}

void main()

{ int m,s,t,i,j,k,w; while(cin>>n>>m) { for (i=0; i>i>>j>>w;arc[i][j]=w;} cin>>s>>t; Dijk(s,t); }

}

9091:名次排序

Problem Description

有N个比赛队（1<=N<=500），编号依次为1，2，3，。。。。，N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排名时P1在P2之前。现在请你编程序确定排名。 Input

输入有若干组，每组中的第一行为二个数N（1<=N<=500）和M，其中N表示队伍的个数，M表示接着有M行的输入数据。接下来的M行数据中，每行也有两个整数P1和P2，表示P1队赢了P2队。 Output

给出一个符合要求的排名。输出时队伍号之间有空格，最后一名后面没有空格。

其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。 Sample Input 4 3 1 2 2 3 4 3

Sample Output

1 2 4 3

//9091ANSWER CODE1 #include using namespace std; int n,arc[500][500]; void main()

{ int m,i,j,k,f,num,indg[500],visit[500]; while(cin>>n>>m) { for (i=1; i<=n; i++){for (j=1; j<=n; j++)arc[i][j]=0;} for(k=0;k>i>>j;arc[i][j]=1;} for (i=1; i<=n; i++){indg[i]=0;visit[i]=0;}

}

for (j=1; j<=n; j++)

{for (i=1; i<=n; i++){indg[j]+=arc[i][j];}} f=0;num=0; while(num

cout<

}

//9091ANSWER CODE2 #include using namespace std;

struct arcNode{int adjvex;arcNode *next;};

struct vertexNode{int in;int vertex;arcNode *firstedge;}; int n;vertexNode adjlist[500]; void main()

{ int m,i,j,k;arcNode *s,*p; while(cin>>n>>m) { for (i=1; i<=n; i++) { adjlist[i].in=0; adjlist[i].vertex=i; adjlist[i].firstedge=NULL; } for (k=0; k>i>>j; s=new arcNode; s->adjvex=j; s->next=adjlist[i].firstedge; adjlist[i].firstedge=s; } for(i=1; i<=n; i++) { p=adjlist[i].firstedge ; while(p){adjlist[p->adjvex].in++ ;p=p->next ;} } int S[500],top=-1,count=0,f=0; for (i=n; i>=1; i--){if (adjlist[i].in==0) S[++top]=i;}

while(top!= -1 ) //当图有入度为0的顶点时循环

}

}

{

j=S[top--]; //从栈中取出一个入度为0的顶点 if(f==0){cout<

p=adjlist[j].firstedge;//扫描顶点表，找出顶点j的所有出边 while(p) {

adjlist[p->adjvex].in--;//将入度减1，=0顶点入栈

if (adjlist[p->adjvex].in==0) S[++top]=p->adjvex; p=p->next;

} }

cout<

9085:逆邻接表

Problem Description

对每个顶点vi将所有以顶点vi为弧头的弧链接起来，形成入边表，可以建立有向图的逆邻接表，从而便于求顶点的入度。设有一有向图G，其顶点值为字符型并假设各值互不相等，要求采用逆邻接表表示法存储。设计一个算法，存储该有向图并输出各顶点的入边信息。 Input

有多组测试数据，每组数据的第一行为两个整数n和e，表示n个顶点和e条边（0

输出该有向图中所有顶点的入边信息（空表不输出任何信息），每行最后均无空格，每两组数据之间有一空行，具体格式见样例。 Sample Input 4 4 ABCD 0 1 0 3 1 2 1 3 4 4 ABCD 0 1 0 2 2 3 3 0

Sample Output 1->0 2->1

3->1->0 0->3 1->0 2->0 3->2

//9085ANSWER CODE1 #include using namespace std;

struct arcNode{int adjvex;arcNode *next;};

struct vertexNode{char vertex;arcNode *firstedge;}; void main()

{ int n,e,i,j,k,f=0;char vex[20];vertexNode adjlist[20];arcNode *s,*p; while(cin>>n>>e>>vex) { if(f)cout<>i>>j; s=new arcNode; s->adjvex=i; s->next=adjlist[j].firstedge; adjlist[j].firstedge=s; } for (i=0; i

}

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ 第一次实验：顺序表9010，9005

9010:拆分顺序表 Problem Description

有一顺序表A，请将其拆分成两个顺序表B和C，使A中大于0的元素存放在B中，小于或等于0的元素存放在C中。

Input

有多组数据，每组第一行表示A表长n（0

将顺序表B和C的元素分两行输出，每行中相邻两元素之间用一个空格分隔，空表则不输出任何信息。 Sample Input 9

11 3 -3 3 -4 0 -2 6 32 Sample Output

11 3 3 6 32 -3 -4 0 -2

//9010ANSWER CODE1 #include using namespace std; int main() { int n,i,j,k,A[21],B[21],C[21]; while(cin>>n) { if(n>0 && n<=20) { for(i=0;i>A[i]; j=k=0; for(i=0;i0) B[j++]=A[i]; else C[k++]=A[i]; } if(j>0){ for(i=0;i0){ for(i=0;i

}

9005:最长相等子序列长度

Problem Description

给定一个有n个元素的整数数组b，b中连续的相等元素构成的子序列称为平台。设计一个算法求b中最长平台的长度。 Input

第一行为一个数字m，表示下面有m组数据，每组数据包括2行；每组数据中的第一行表示数组的长度n（不会超

过20，但可为空表），第二行表示数组的所有元素。 Output

输出最长平台的长度。 Sample Input 2 8

11 3 8 8 8 8 8 7 10

11 3 3 25 8 8 8 8 8 7 Sample Output

5 5

//9005ANSWER CODE1 #include using namespace std; int main() { int m,n,i,b[21],c,max; cin>>m; while(m--) { cin>>n; if(n<=0 || n>20) {cout<<\ for(i=0;i>b[i]; i=0;c=max=1; do{ while((b[i]==b[i+1])&&(imax) max=c; c=1; } while(i

第二次实验：顺序表2 9097

9097:杀猪！！

Problem Description

一户人家养了一群猪(n头,编号1,2,3....n)，每头猪都有自己初始体重w(double)和体重增长率x。每天猪的体重都会

发生变化，是胖是瘦取决于体重增长率，体重增长率为负，变瘦，为正，变胖。(体重增长率：double,-0.2

输入数据有多组，每组数据第一行为猪的头数n(0

第二行为n头猪的体重

第三行为n头猪的体重增长率 Output

按先后被杀的顺序输出猪的编号。每组输出数据，输出一行，编号之间用逗号隔开 Sample Input 6

4 32 99 3 2 45

0.1 -0.15 0 -0.19 0.19 -0.04 Sample Output

3,6,2,1,5,4

//9097ANSWER CODE1 #include using namespace std; int main() {

int n,i,j,flag,maxi;double max;//max一定是double类型 while(cin>>n) { if(n<=50 && n>0) { double * pw=new double[n+1]; double * px=new double[n+1]; for(i=1;i<=n;i++)cin>>pw[i]; for(i=1;i<=n;i++)cin>>px[i]; flag=1; for(j=1;j<=n;j++) { max=0;maxi=0;

for(i=1;i<=n;i++){if(pw[i]>max){max=pw[i];maxi=i;}} if(flag==1){cout<

return 0;

}

第三次实验：单链表9007

9007:单链表按值操作

Problem Description

对值递增有序的单链表进行以下操作：若表中存在值为x的结点，则将它从表中删除；否则，就往表中插入一个值为x的结点，并保持表值递增有序的性质不变（假设表中没有值相同的元素）。处理后若为空表则不输出。

Input

每组数据包括3行，第一行表示单链表的长度n（不会超过50）；第二行表示单链表的所有元素；第三行表示x值。 Output

输出执行操作后的单链表，元素之间用一个空格分隔。 Sample Input 5

1 3 5 7 9 3 5

1 3 5 7 9 4

Sample Output

1 5 7 9 1 3 4 5 7 9

//9007ANSWER CODE1 #include using namespace std;

struct Node{ int data; Node * next;}; int main(){ int i,n,x,A[51]; Node *p,*first,*q,*r,*s; while(cin>>n){ if(n==0){ cin>>x; cout<next=NULL; s=new Node; s->data=x; s->next=first->next; first->next=s; } else if(n>=1 && n<=50){ for(i=0;i>A[i];} cin>>x; //尾插法creaLinkList first=new Node; first->next=NULL; r=first; for(i=0;idata=A[i]; s->next=r->next; r->next=s; r=s; } //按值查找 p=first->next;q=first; while(p){ if(p->data==x){ q->next=p->next; delete p; break; } else if(p->datanext;}

4 6

//9054ANSWER CODE1 #include using namespace std;

struct BiNode{char data;BiNode *lchild,*rchild;}; int num=0;

BiNode *Creat(){ char ch;BiNode *p; cin>>ch; if(ch=='#') return NULL; else {p=new BiNode;p->data=ch;num++;

本文来源：https://www.bwwdw.com/article/9eno.html