数据结构教程(第3版)—李春葆第3章答案

一、绪论选择题1.数据结构是一门研究非数值计算的程序设计问题计算机的以及它们之间的和运算等的学科。

1 A.数据元素 B.计算方法 C.逻辑存储 D.数据映像2 A.结构 B.关系 C.运算 D.算法2.数据结构被形式地定义为(K, R)，其中K是的有限集，R是K上的有限集。

1 A.算法 B.数据元素 C.数据操作 D.逻辑结构2 A.操作 B.映像 C.存储 D.关系3.在数据结构中，从逻辑上可以把数据结构分成。

A.动态结构和静态结构B.紧凑结构和非紧凑结构C.线性结构和非线性结构D.内部结构和外部结构4.线性结构的顺序存储结构是一种的存储结构，线性表的链式存储结构是一种的存储结构。

A.随机存取B.顺序存取C.索引存取D.散列存取5.算法分析的目的是，算法分析的两个主要方面是。

1 A.找出数据结构的合理性 B.研究算法中的输入和输出的关系C.分析算法的效率以求改进D.分析算法的易懂性和文档性2 A.空间复杂度和时间复杂度 B.正确性和简单性C.可读性和文档性D.数据复杂性和程序复杂性6.计算机算法指的是，它必须具备输入、输出和等5个特性。

1 A.计算方法 B.排序方法 C.解决问题的有限运算序列 D.调度方法2 A.可执行性、可移植性和可扩充性 B.可行性、确定性和有穷性C.确定性、有穷性和稳定性D.易读性、稳定性和安全性7.线性表的逻辑顺序与存储顺序总是一致的，这种说法。

A.正确B.不正确8线性表若采用链式存储结构时，要求内存中可用存储单元的地址。

A.必须连续的B.部分地址必须连续的C.一定是不续的D连续不连续都可以9.以下的叙述中，正确的是。

A.线性表的存储结构优于链式存储结构B.二维数组是其数据元素为线性表的线性表C.栈的操作方式是先进先出D.队列的操作方式是先进后出10.每种数据结构都具备三个基本运算：插入、删除和查找，这种说法。

A.正确B.不正确填空题1.数据逻辑结构包括三种类型、和，树形结构和图形结构合称为。

数据结构（第3版）习题答案⼗⼆五普通⾼等教育国家级本科规划教材第1章绪论⾼等学校精品资源共享课程1.1什么是数据结构？【答】：数据结构是指按⼀定的逻辑结构组成的⼀批数据，使⽤某种存储结构将这批数据存储于计算机中，并在这些数据上定义了⼀个运算集合。

1.2数据结构涉及哪⼏个⽅⾯？【答】：数据结构涉及三个⽅⾯的内容，即数据的逻辑结构、数据的存储结构和数据的运算集合。

1.3两个数据结构的逻辑结构和存储结构都相同，但是它们的运算集合中有⼀个运算的定义不⼀样，它们是否可以认作是同⼀个数据结构？为什么？【答】：不能，运算集合是数据结构的重要组成部分，不同的运算集合所确定的数据结构是不⼀样的，例如，栈与队列它们的逻辑结构与存储结构可以相同，但由于它们的运算集合不⼀样，所以它们是两种不同的数据结构。

1.4线性结构的特点是什么？⾮线性结构的特点是什么？【答】：线性结构元素之间的关系是⼀对⼀的，在线性结构中只有⼀个开始结点和⼀个终端结点，其他的每⼀个结点有且仅有⼀个前驱和⼀个后继结点。

⽽⾮线性结构则没有这个特点，元素之间的关系可以是⼀对多的或多对多的。

1.5数据结构的存储⽅式有哪⼏种？【答】：数据结构的存储⽅式有顺序存储、链式存储、散列存储和索引存储等四种⽅式。

1.6算法有哪些特点？它和程序的主要区别是什么？【答】：算法具有（1）有穷性（2）确定性（3）0个或多个输⼊（4）1个或多个输出（5）可⾏性等特征。

程序是算法的⼀种描述⽅式，通过程序可以在计算机上实现算法。

1.7抽象数据类型的是什么？它有什么特点？【答】：抽象数据类型是数据类型的进⼀步抽象，是⼤家熟知的基本数据类型的延伸和发展。

抽象数据类型是与表⽰⽆关的数据类型，是⼀个数据模型及定义在该模型上的⼀组运算。

对⼀个抽象数据类型进⾏定义时，必须给出它的名字及各运算的运算符名，即函数名，并且规定这些函数的参数性质。

⼀旦定义了⼀个抽象数据类型及具体实现，程序设计中就可以像使⽤基本数据类型那样，⼗分⽅便地使⽤抽象数据类型。

数据结构(李春葆)习题与解析编辑整理：尊敬的读者朋友们：这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（数据结构(李春葆)习题与解析）的内容能够给您的工作和学习带来便利。

同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。

本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为数据结构(李春葆)习题与解析的全部内容。

数据结构（C语言篇）―习题与解析（修订版）清华大学出版社一、绪论选择题1.数据结构是一门研究非数值计算的程序设计问题计算机的以及它们之间的和运算等的学科.1 A.数据元素 B。

计算方法C。

逻辑存储 D.数据映像2 A.结构 B.关系 C.运算 D.算法2。

数据结构被形式地定义为（K， R)，其中K是的有限集，R是K 上的有限集。

1A。

算法 B。

数据元素C。

数据操作 D.逻辑结构2A。

操作 B。

映像C。

存储D。

关系3.在数据结构中，从逻辑上可以把数据结构分成。

A.动态结构和静态结构B.紧凑结构和非紧凑结构C。

线性结构和非线性结构 D。

内部结构和外部结构4.线性结构的顺序存储结构是一种A的存储结构，线性表的链式存储结构是一种B的存储结构。

A.随机存取 B。

顺序存取 C.索引存取 D.散列存取5。

算法分析的目的是C，算法分析的两个主要方面是AB。

1 A.找出数据结构的合理性 B。

研究算法中的输入和输出的关系C。

分析算法的效率以求改进 D.分析算法的易懂性和文档性2 A.空间复杂度和时间复杂度 B.正确性和简单性C。

可读性和文档性 D.数据复杂性和程序复杂性6.计算机算法指的是C，它必须具备输入、输出和B等5个特性。

1 A.计算方法 B。

排序方法C。

解决问题的有限运算序列D.调度方法2 A.可执行性、可移植性和可扩充性B。

可行性、确定性和有穷性C.确定性、有穷性和稳定性D.易读性、稳定性和安全性7.线性表的逻辑顺序与存储顺序总是一致的，这种说法B。

资料范本本资料为word版本，可以直接编辑和打印，感谢您的下载数据结构教程习题答案李蓉蓉安杨等编著第三版第三章答案地点：__________________时间：__________________说明：本资料适用于约定双方经过谈判，协商而共同承认，共同遵守的责任与义务，仅供参考，文档可直接下载或修改，不需要的部分可直接删除，使用时请详细阅读内容3.3/********************************************题目：假设表达式中允许包含三种括号，圆括号，方括号和大括号，编写一个算法判断表达式中的括号是不是匹配实践:狼影时间：2012.9.19************************************************/# include <stdio.h># include <stdlib.h># define size 256//定义节点typedef struct{char ex[size];int top;}STACK;//函数声明STACK *init_stack(void);bool is_match(char *exp);bool pop_stack(STACK *stack, char *ch);void push_stack(STACK *stack, char e);main(){char exp[256];printf("输入表达式\n");scanf("%s", exp);if(is_match(exp)){printf("此表达式匹配\n");}else{printf("此表达式不匹配\n");}}//栈的初始化STACK *init_stack(void){STACK *stack = (STACK *)malloc(sizeof(STACK)); if(NULL == stack){printf("内存分配失败\n");exit(-1);}stack->top = -1;return stack;}//判断是不是匹配bool is_match(char *exp){int i = 0;char ch;STACK *stack;stack = init_stack();while(exp[i] != '\0'){if('('==exp[i] || '['==exp[i] || '{'==exp[i]){push_stack(stack, exp[i]);}else if(')'==exp[i] || ']'==exp[i] || '}'==exp[i]) {//线面是匹配的三种情况，switch(exp[i]){case ')':if(pop_stack(stack, &ch)){if(ch != '(')return false;}elsereturn false;break;case ']':if(pop_stack(stack, &ch)) {if(ch != '[')return false;}elsereturn false;break;case '}':if(pop_stack(stack, &ch)) {if(ch != '{')return false;}elsereturn false;break;default:break;}}i++;}if(-1 == stack->top) return true;elsereturn false;}//入栈的操作void push_stack(STACK *stack, char e){stack->top++;stack->ex[stack->top] = e;}//出栈的操作bool pop_stack(STACK *stack, char *ch){if(-1 == stack->top)return false;else{*ch = stack->ex[stack->top];stack->top--;}return true;}/*********************************************** 输入表达式(((1+2+3*5{{{[[[234]]]}}})))此表达式匹配Press any key to continue**********************************************/3.4/*************************************************题目;设从键盘输入一整数序列，编写程序，当ai大于零时，ai进队，当ai小于零时，将对首元素出队当ai等于零时，将表示输入结束，要求用环形队列，进队与出队单独编写算法，并在异常情况下打印出错实践：狼影时间;2012.9.20***************************************************************/ # include <stdio.h># include <stdlib.h># define size 100typedef struct{int node[size];int front;int rear;}QUEUE;//函数声明QUEUE *init_queue(void);bool en_queue(QUEUE *queue, int e);bool out_queue(QUEUE *queue);void print_queue(QUEUE *queue); main(){QUEUE *queue;int arry[size];int n;int i;queue = init_queue();printf("输入数字的个数\n"); scanf("%d", &n);printf("请输入数据\n");for(i = 0; i<n; i++){scanf("%d", &arry[i]);}i = 0;while(i<n){if(arry[i]>0){if(!en_queue(queue, arry[i])) {printf("进队出错\n");break;}if(arry[i]<0)if(!out_queue(queue)){printf("出队错误\n");break;}if(arry[i] == 0){break;}i++;}printf("队列内容是\n");print_queue(queue);printf("\n");}//初始化队列QUEUE *init_queue(void){QUEUE *queue = (QUEUE *)malloc(sizeof(QUEUE)); if(NULL == queue){printf("内存分配错误\n");exit(-1);queue->front = queue->rear = -1;return queue;}//进队的操作bool en_queue(QUEUE *queue, int e){if(queue->front == (queue->rear+1)%size) return false;else{queue->rear = (queue->rear+1)%size; queue->node[queue->rear] = e;}return true;}//进行出队操作bool out_queue(QUEUE *queue){if(queue->rear == queue->front)return false;elsequeue->front = (queue->front+1)%size; return true;}//打印队列void print_queue(QUEUE *queue){if(queue->front == queue->rear){printf("队列为空\n");return;}else{while(queue->front != queue->rear){queue->front = (queue->front+1)%size; printf("%d ", queue->node[queue->front]); }}}/***************************输入数字的个数5请输入数据1 2 3 -1 4队列内容是2 3 4Press any key to continue****************************/3.5/****************************************************题目：编写一个算法，将一个环形队列（容量为n，元素下标从1到n）的元素倒置（具体的图请参考课本p88）设计;狼影时间：2012.9.20********************************************/# include <stdio.h># include <stdlib.h>/******************************************解此题的思路是将队列中的数据先转到栈中，然后再把栈中的数据转到另一个队列中，实现倒置对照书中给的图来初始化两个队列图参考课本88页也有其他简单的方法，如果你想到告诉我一声啊，，共同学习吗！************************************************/typedef struct{char c[20];int top;}STACK;typedef struct{char ch[20];int rear;int front;}QUEUE;//函数声明void creat_queue(QUEUE *queue);QUEUE *init_queue1(void);void traverse(QUEUE *queue1, QUEUE *queue2, STACK *stack); STACK *init_stack(void);QUEUE *init_queue2(void);void creat_queue(QUEUE *queue);void print_queue(QUEUE *queue);main(){QUEUE *queue1, *queue2;STACK *stack;stack = init_stack();queue1 = init_queue1();queue2 = init_queue2();creat_queue(queue1);traverse(queue1, queue2, stack);print_queue(queue2);}//初始化队列QUEUE *init_queue1(void){if(NULL == queue){printf("内存分配错误\n");exit(-1);}queue->front = 8;queue->rear = 8;return queue;}//栈的初始化STACK *init_stack(void){STACK *stack = (STACK *)malloc(sizeof(STACK)); if(NULL == stack){printf("内存分配错误\n");exit(-1);}stack->top = -1;return stack;}//队列的初始化QUEUE *init_queue2(void){if(NULL == queue){printf("内存分配错误\n");exit(-1);}queue->front = 10;queue->rear = 0;return queue;}//创建队列void creat_queue(QUEUE *queue){char c;for(c = 'a'; c<='f'; c++){queue->rear = (queue->rear)%10+1;queue->ch[queue->rear] = c;}}//数的转置void traverse(QUEUE *queue1, QUEUE *queue2, STACK *stack) {queue1->front = (queue1->front)%10+1;//将队列中的数出队放到栈中{stack->top++;stack->c[stack->top] = queue1->ch[queue1->front]; queue1->front = (queue1->front)%10+1;}stack->top++;stack->c[stack->top] = queue1->ch[queue1->front]; free(queue1);//将元素出栈，放到队列中queue2->rear = (queue2->rear)%10+1;while(stack->top != -1){queue2->ch[queue2->rear] = stack->c[stack->top]; stack->top--;queue2->rear = (queue2->rear)%10+1;}}//打印队列中的内容void print_queue(QUEUE *queue){queue->front = (queue->front)%10+1;while(queue->front != queue->rear){printf("%c ", queue->ch[queue->front]);}printf("\n");}3.6/***************************************题目:输入n个10以内的数每输入i（0<=i<=9)就把它插入到第i号队列，最后把10个队中非空队列，按队列号从小到大的顺序串接成一条链，并输出该链的所有元素设计：狼影时间：2012.9.20***************************************************************** */# include <stdio.h># include <stdlib.h>//在这里用链表的形式来创建队列typedef struct node{int data;struct node *pNext;}NODE;typedef struct{NODE *front;NODE *rear;}QUEUE;//函数的声明NODE *init_link(void);QUEUE *init_queue(void);void en_queue(QUEUE *queue, int i);void print_link(NODE *pHead);void en_queue(QUEUE *queue, int i);bool is_empty(QUEUE *queue);void put_link(QUEUE *queue, NODE *pHead); main(){int n, i, j;QUEUE *queue[10];NODE *pHead;//初始化化链表pHead = init_link();//初始化10个队列for(j = 0; j<10; j++){queue[j] = init_queue();}//输入输入数的个数printf("请输入数的个数n\n");scanf("%d", &n);printf("请输入i值(0<=i<=9)\n");for(j = 0; j<n; j++){do{scanf("%d", &i);if(i<0 || i>=10){printf("你输入第%d个数据错误, 请重新输入\n", j+1); }}while(i<0 || i>=10); //当i值满足条件时，循环结束//将i值放入相应的队列中switch(i){case 0: en_queue(queue[0], i);break;case 1: en_queue(queue[1], i);break;case 2: en_queue(queue[2], i);break;case 3: en_queue(queue[3], i);break;case 4: en_queue(queue[4], i);break;case 5: en_queue(queue[5], i);break;case 6: en_queue(queue[6], i); break;case 7: en_queue(queue[7], i); break;case 8: en_queue(queue[8], i); break;case 9: en_queue(queue[9], i); break;default:break;}}//将队列中的内容放入链表for(i = 0; i<10; i++){if(!is_empty(queue[i])){put_link(queue[i], pHead);}}//打印链表printf("链表中的内容是\n"); print_link(pHead);}//初始化队列QUEUE *init_queue(void){QUEUE *queue;queue = (QUEUE *)malloc(sizeof(QUEUE));if(NULL == queue){printf("内存分配错误\n");exit(-1);}queue->front = (NODE *)malloc(sizeof(NODE)); if(NULL == queue->front){printf("内存分配错误\n");exit(-1);}queue->front->pNext = NULL;queue->rear = queue->front;return queue;}//链表的初始化NODE *init_link(void){NODE *pHead = (NODE *)malloc(sizeof(NODE)); if(NULL == pHead){printf("内存分配错误\n");exit(-1);}pHead->pNext = NULL;return pHead;}//进队列的操作void en_queue(QUEUE *queue, int i){NODE *pNew;pNew = (NODE *)malloc(sizeof(NODE));if(NULL == pNew){printf("内存分配错误\n");exit(-1);}pNew->pNext = NULL;pNew->data = i;queue->rear->pNext = pNew;queue->rear = pNew;}//将队列中的数据放入链表中void put_link(QUEUE *queue, NODE *pHead) {NODE *pNow = queue->front->pNext;NODE *pNew = pHead;while(NULL != pNew->pNext)pNew = pNew->pNext;pNew->pNext = queue->front->pNext; queue->front = queue->rear = NULL; free(queue);}//打印链表void print_link(NODE *pHead){NODE *pNow = pHead->pNext;if(NULL == pNow){printf("链表为空\n");return;}while(NULL != pNow){printf("%d ", pNow->data);pNow = pNow->pNext;}printf("\n");}//判断是不是空bool is_empty(QUEUE *queue){if(queue->front == queue->rear)return true;elsereturn false;}/*****************************************请输入数的个数n6请输入i值(0<=i<=9)1 3 4 102 3你输入第4个数据错误, 请重新输入3链表中的内容是1 2 3 3 3 4Press any key to continue********************************************************/。

head第3章 栈和队列 自测卷答案 姓名 班级一、填空题（每空1分，共15分）1. 【李春葆】向量、栈和队列都是 线性 结构，可以在向量的 任何 位置插入和删除元素；对于栈只能在 栈顶 插入和删除元素；对于队列只能在 队尾 插入和 队首 删除元素。

2. 栈是一种特殊的线性表，允许插入和删除运算的一端称为 栈顶 。

不允许插入和删除运算的一端称为 栈底 。

3. 队列 是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。

4. 在一个循环队列中，队首指针指向队首元素的 前一个 位置。

(注：不一定，这是一种约定，在殷教材中是队首指针指向队列的首元素位置)5. 在具有n 个单元的循环队列中，队满时共有 n-1 个元素。

6. 向栈中压入元素的操作是先 移动栈顶指针 ，后 存入元素 。

7. 从循环队列中删除一个元素时，其操作是 先 移动队首指针 ，后 取出元素 。

(注：不一定，这是一种约定，在殷教材中是先 取出元素 ，后移动队首指针 )8. 〖00年统考题〗带表头结点的空循环双向链表的长度等于 0 。

解：二、判断正误（判断下列概念的正确性，并作出简要的说明。

）（每小题1分，共10分） （ × ）1. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。

错，线性表是逻辑结构概念，可以顺序存储或链式存储，与元素数据类型无关。

（ × ）2. 在表结构中最常用的是线性表，栈和队列不太常用。

错，不一定吧调用子程序或函数常用，CPU 中也用队列。

（ √ ）3. 栈是一种对所有插入、删除操作限于在表的一端进行的线性表，是一种后进先出型结构。

（√）4. 对于不同的使用者，一个表结构既可以是栈，也可以是队列，也可以是线性表。

正确，都是线性逻辑结构，栈和队列其实是特殊的线性表，对运算的定义略有不同而已。

（×）5. 栈和链表是两种不同的数据结构。

错，栈是逻辑结构的概念，是特殊殊线性表，而链表是存储结构概念，二者不是同类项。

第三章习题1.按图 3.1(b) 所示铁道（两侧铁道均为单向行驶道）进行车厢调度，回答：⑴如进站的车厢序列为123，则可能得到的出站车厢序列是什么？⑵如进站的车厢序列为 123456，能否得到 435612 和 135426 的出站序列，并说明原因。

（即写出以“ S”表示进栈、以“ X”表示出栈的栈操作序列）。

2.设队列中有A、B、C、D、E这5个元素，其中队首元素为A。

如果对这个队列重复执行下列 4 步操作：（1）输出队首元素；（2）把队首元素值插入到队尾；（3）删除队首元素；（4）再次删除队首元素。

直到队列成为空队列为止，得到输出序列：（1）A、C、E、C、C（2）A、C、E（3） A 、C、E、C、C、C（4）A、C、E、C3.给出栈的两种存储结构形式名称，在这两种栈的存储结构中如何判别栈空与栈满？4.按照四则运算加、减、乘、除和幂运算（↑）优先关系的惯例，画出对下列算术表达式求值时操作数栈和运算符栈的变化过程：A－B＊Ｃ／Ｄ＋Ｅ↑Ｆ5.试写一个算法，判断依次读入的一个以 @为结束符的字母序列，是否为形如‘序列 1 & 序列 2’模式的字符序列。

其中序列 1 和序列 2 中都不含字符’ &’，且序列 2 是序列 1 的逆序列。

例如，‘a+b&b+a’是属该模式的字符序列，而‘１ +３&３－１’则不是。

6.假设表达式由单字母变量和双目四则运算算符构成。

试写一个算法，将一个通常书写形式且书写正确的表达式转换为逆波兰式。

7.假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的队列初始化、入队列和出队列的算法。

8.要求循环队列不损失一个空间全部都能得到利用,设置一个标志域tag ,以tag为0或1来区分头尾指针相同时的队列状态的空与满，请编写与此结构相应的入队与出队算法。

9.简述以下算法的功能（其中栈和队列的元素类型均为int ）：（1） void proc_1(Stack S){ int i, n, A[255];n=0;while(!EmptyStack(S)){n++; Pop(&S, &A[n]);} for(i=1; i<=n; i++)Push(&S, A[i]);}（2） void proc_2(Stack S, int e) { Stack T; int d;InitStack(&T);while(!EmptyStack(S)){ Pop(&S, &d);if (d!=e) Push( &T, d);}while(!EmptyStack(T)){ Pop(&T, &d);Push( &S, d);}}（3） void proc_3(Queue *Q){ Stack S; int d;InitStack(&S);while(!EmptyQueue(*Q)){DeleteQueue(Q, &d);Push( &S, d);}while(!EmptyStack(S)){ Pop(&S, &d);EnterQueue(Q，d)}}实习题1．回文判断。

数据结构教程(第三版)课后答案/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType; typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L) {L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L) {free(L);}int ListEmpty(SqList *L) {return(L->length==0); }int ListLength(SqList *L) {return(L->length);}void DispList(SqList *L) {int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) {if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++; if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e) {int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/ L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}/*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType; typedef struct LNode /*定义单链表结点类型*/ {ElemType data;struct LNode *next; } LinkList;void InitList(LinkList *&L) {L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L) {return(L->next==NULL); }int ListLength(LinkList *L) {LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L) {LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e) {int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}/*文件名:algo2-3.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType; typedef struct DNode /*定义双链表结点类型*/ { ElemType data;struct DNode *prior; /*指向前驱结点*/struct DNode *next; /*指向后继结点*/ } DLinkList;void InitList(DLinkList *&L) {L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/L->prior=L->next=NULL; }void DestroyList(DLinkList *&L) {DLinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L) { return(L->next==NULL); }int ListLength(DLinkList *L) {DLinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(DLinkList *L) { DLinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(DLinkList *L,ElemType e) {int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e) {int j=0;DLinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}int ListDelete(DLinkList *&L,int i,ElemType &e){int j=0;DLinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/if (q==NULL) return 0; /*不存在第i个结点*/p->next=q->next; /*从单链表中删除*q结点*/if (p->next!=NULL) p->next->prior=p;free(q); /*释放*q结点*/return 1;}}void Sort(DLinkList *&head) /*双链表元素排序*/{DLinkList *p=head->next,*q,*r;if (p!=NULL) /*若原双链表中有一个或以上的数据结点*/{r=p->next; /*r保存*p结点后继结点的指针*/p->next=NULL; /*构造只含一个数据结点的有序表*/p=r;while (p!=NULL){r=p->next; /*r保存*p结点后继结点的指针*/q=head;while (q->next!=NULL && q->next->data<p->data) /*在有序表中找插入*p 的前驱结点*q*/q=q->next;p->next=q->next; /*将*p插入到*q之后*/if (q->next!=NULL) q->next->prior=p;q->next=p;p->prior=q;p=r;}}}/*文件名:algo2-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/ { ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L) {L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/ L->next=L;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L) { return(L->next==L); }int ListLength(LinkList *L) { LinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(LinkList *L) { LinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p;if (L->next!=L) /*单链表不为空表时*/{if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else /*单链表为空表时*/return 0;}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=L && p->data!=e){p=p->next;n++;}if (p==L)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e) {int j=0;LinkList *p=L,*s;if (p->next==L || i==1) /*原单链表为空表或i==1时*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}else{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}}int ListDelete(LinkList *&L,int i,ElemType &e) {int j=0;LinkList *p=L,*q;if (p->next!=L) /*原单链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}}else return 0;}/*文件名:algo2-5.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType; typedef struct DNode /*定义双链表结点类型*/ { ElemType data;struct DNode *prior; /*指向前驱结点*/struct DNode *next; /*指向后继结点*/ } DLinkList;void InitList(DLinkList *&L) {L=(DLinkList *)malloc(sizeof(DLinkList)); /*创建头结点*/L->prior=L->next=L;}void DestroyList(DLinkList *&L) { DLinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(DLinkList *L) { return(L->next==L);}int ListLength(DLinkList *L){DLinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(DLinkList *L){DLinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(DLinkList *L,int i,ElemType &e) {int j=0;DLinkList *p;if (L->next!=L) /*双链表不为空表时*/{if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else /*双链表为空表时*/return 0;}int LocateElem(DLinkList *L,ElemType e) {int n=1;DLinkList *p=L->next;while (p!=NULL && p->data!=e){n++;p=p->next;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(DLinkList *&L,int i,ElemType e){int j=0;DLinkList *p=L,*s;if (p->next==L) /*原双链表为空表时*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;p->next=s;s->next=p;p->prior=s;s->prior=p;return 1;}else if (i==1) /*原双链表不为空表但i=1时*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next;p->next=s; /*将*s插入到*p之后*/s->next->prior=s;s->prior=p;return 1;}else{p=L->next;while (j<i-2 && p!=L){ j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(DLinkList *)malloc(sizeof(DLinkList)); /*创建新结点*s*/ s->data=e;s->next=p->next; /*将*s插入到*p之后*/if (p->next!=NULL) p->next->prior=s;s->prior=p;p->next=s;return 1;}}}int ListDelete(DLinkList *&L,int i,ElemType &e) {int j=0;DLinkList *p=L,*q;if (p->next!=L) /*原双链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;q->next->prior=L;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/if (q==NULL) return 0; /*不存在第i个结点*/ p->next=q->next; /*从单链表中删除*q结点*/ if (p->next!=NULL) p->next->prior=p;free(q); /*释放*q结点*/return 1;}}}else return 0; /*原双链表为空表时*/}/*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType; typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s) {s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s) { free(s);}int StackLength(SqStack *s) { return(s->top+1);}int StackEmpty(SqStack *s) {return(s->top==-1);}int Push(SqStack *&s,ElemType e) { if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e) {if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;}int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s) {int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h> typedef char ElemType; typedef struct linknode { ElemType data; /*数据域*/struct linknode *next; /*指针域*/ } LiStack;void InitStack(LiStack *&s) {s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s) {LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s) {int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s) { return(s->next==NULL); }void Push(LiStack *&s,ElemType e) {LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/ s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType; typedef struct {ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q) {q=(SqQueue *)malloc (sizeof(SqQueue)); q->front=q->rear=0;}void ClearQueue(SqQueue *&q) {free(q);}int QueueEmpty(SqQueue *q) {return(q->front==q->rear); }int QueueLength(SqQueue *q) {return (q->rear-q->front+MaxSize)%MaxSize;}int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}/*文件名:algo3-4.cpp*/ #include <stdio.h> #include <malloc.h> typedef char ElemType; typedef struct qnode {ElemType data;struct qnode *next; } QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue)); q->front=q->rear=NULL; }void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/ {r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q) {if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/ q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/ q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/ {t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/ typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/int len; /*标记当前实际串长*/ } SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ { int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/ same=0;}return same;}int StrLength(SqString s) {return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0],s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0],t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j) {SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i],s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0],s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0],s2.ch[s2.len-1]复制到str*/ str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1],s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j) {int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0],s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1],ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0],s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0],t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1],ch[s.len-1]复制到str*/ str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str) {int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}/*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]) { int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t) { LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t) { LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data) {p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t) { LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString)); str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j) {int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t) {int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j) {int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t) { int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s) {LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}/*文件名:algo7-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct node{ElemType data; /*数据元素*/struct node *lchild; /*指向左孩子*/struct node *rchild; /*指向右孩子*/} BTNode;void CreateBTNode(BTNode *&b,char *str) /*由str串创建二叉链*/ { BTNode *St[MaxSize],*p=NULL;int top=-1,k,j=0;char ch;b=NULL; /*建立的二叉树初始时为空*/ch=str[j];。