数据结构实验二11180
北京信息科技大学数据结构实验二链栈,循环队列和计算器的操纵

SNode_N *p; p=(SNode_N *)malloc(sizeof(SNode_N)); if(!p) exit(0); p->data=e; p->next=S->top; S->top=p; S->length++; return 1; }
if(!S.top)return 0; else {
printf("返回栈顶元素%5d\n",S.top->data); } return 0; }//返回栈顶元素
int PrintStack(SqStack &S) {
Stack p; printf("\n 链式队列中的元素"); p=S.top; if(S.top!=NULL) {
int InitStack(SqStack & S) {
S.top=NULL; S.length=0; return 0; }//初始化链式栈
int Push(SqStack &S,int e) {
Stack p; p=(Stack)malloc(sizeof(SNode)); if(!p)exit(0); p->data=e; p->next=S.top; S.top=p; S.length++; return 0; }//插入元素 e
float s; switch(c){
case '+':s=a+b; break; case '-':s=a-b; break; case '*':s=a*b; break; case '/':
数据结构第二次实验报告

2.巩固对这两种结构方法的掌握。 3.接触较复杂问题的递归算法设计。
签名 2014 年 评语与成绩:
பைடு நூலகம்
郑小玉 11 月
20
日
教师签名: 年
月
日
实验内容: (数制转换操作) int conversion(int N,int d) { //N:表示十进制正整数,d 表示 2 到 16 之间的某种进制 //面实现将十进制整数 N 转换成某种 d 进制数,并输出显示。 SqStack S; int e; InitStack(S);//构造空栈 while(N) { Push(S, N % d); N = N / d; } while(!StackEmpty(S)) { Pop(S,e); if(e<10) cout<<e; else cout<<e+55; } cout<<endl; }
《数据结构》实验报告模板(附实例)--实验一线性表的基本操作实现

《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现,其中以熟悉各种链表的操作为重点。
2、巩固高级语言程序设计方法与技术,会用线性链表解决简单的实际问题。
二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书,提前做好实验预习与准备工作。
2、加“*”题目必做,其他题目任选;多选者并且保质保量完成适当加分。
3、严格按照数据结构实验报告模板和规范,及时完成实验报告。
四、实验步骤(说明:依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作(成员函数)的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码)㈠、数据结构与核心算法的设计描述(程序中每个模块或函数应加注释,说明函数功能、入口及出口参数)1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释,说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释,说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针,返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针,本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计(可用函数的调用关系图说明)㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图:2、程序清单(程序过长,可附主要部分)说明:以后每次实验报告均按此格式书写。
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案

{
output(p);
p=p->next;
}
printf("\n");
}
//输出最高分及最低分评委信息,删除最高分及最低分结点并计算参赛者的最后平均分
void calc(NODE *head)
{
NODE *q,*p,*pmin,*pmax;
float sum=0; //总分
导
教
师
评
语
指导教师 日期
printf("\n");
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
if(p==pmax) { q->next=p->next; p=q; } //删除最高分结点
p=p->next;
}
//输出最高分及最低分评委信息
printf("给出最高分的评委姓名:%6s年龄:%d评分:%6.2f\n",pmax->,pmax->data.age,pmax->data.score);
printf("给出最低分的评委姓名:%6s年龄:%d评分:%6.2f\n",pmin->,pmin->data.age,pmin->data.score);
float ave=0; //平均分
//查找最高分和最低分并计算总分
p=head->next;
pmin=pmax=p;
北邮数据结构试验报告试验二含源码

数据结构实验报告实验名称:实验二一一栈和队学生姓名:申宇飞班级:班内序03号:学号:日期2013年11月18日:1- 实验要求1.1实验目的:通过选择卞面五个题目之一进行实现,掌握如卞内容:>进一步掌握指针、模板类、异常处理的使用>掌握栈的操作的实现方法>掌握队列的操作的实现方法>学习使用栈解决实际问题的能力>学习使用队列解决实际问题的能力1.2实验内容题目1根据栈和队列的抽象数据类型的定义,按要求实现一个栈或一个队列。
要求:1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试mainO函数测试线性表的正确性。
2.程序分析2.1存储结构链栈:栈的链式存储结构,其实现原理类似于单链表,结点结构与单链表相同,但链栈在实现时直接采用栈顶指针指向栈顶元素。
第]页北京邮电大学信息与通信工程学院data next栈顶栈底关键算法分析链栈:一、入栈操作算法步骤:自然语言描述:1、建立新结点2、给p结点的数据域赋值3、修改p结点的指针域,将其指向栈顶结点4、栈顶指针指向p结点伪代码描述:1)Node<T> * s = new Node<T>;2)p->data = x;3)p->next = top;4)top = p;二、出栈操作算法步骤:自然语言描述:1、判断栈是否为空2、保存栈顶结点的数据域3、定义指针p指向栈顶结点4、栈顶指针指向下一个结点5、释放p结点伪代码描述:1)if(EmptyO)throw" F溢“;2)T x = top->data;3)Node<T> * p = top;4)top = top->next;5)elete p;三、链栈的取栈顶元素算法步骤:自然语言描述:1、判断栈是否为空第3页2、定义指针p指向栈顶结点3、返回栈顶元素的值,不删除伪代码描述1)if(EmptyO)tlu'ow H卜溢";2)Node<T>*p=top;3)cout«p->data;四、遍历链栈元素算法步骤:自然语言描述:1、定义指针p指向栈顶结点2、判断栈是否为空3、返回栈元素的值4、把下一个指针的值赋给p 伪代码描述:1)Node<T>*p = top;2)while(p !=NULL)3)cout« p->data ;4)p = p->next;五、析构函数算法步骤:自然语言描述:1、判断栈顶指针是否为空2、定义指针p指向栈顶结点3、把下一个指针的值赋给栈顶指针4、释放要释放的指针伪代码描述:1)while(top)2)strnct Node <T> * p = top;3)top = top->next;4)deletep; 时间复杂的:0(1)。
中国农业大学_821数据结构_《数据结构》实验笔记(2)

实验2 线性表课程实验共安排8个难度各易的实验,训练重点在于掌握基本的数据结构,而不强调面面俱到。
通过实验,掌握抽象数据类型的概念和基本数据结构,掌握各种数据结构内在的逻辑关系,各种数据结构在计算机中的存储表示,基于各种数据结构上的基本运算、算法实现及算法分析。
●实验目的(1) 掌握用Turbo C 2.0上机调试线性表的基本方法。
(2) 掌握线性表基本操作,如:插入、删除、查找、线性表合并等运算在顺序存储结构和链式存储结构上的运算。
●实验内容1. 线性表基本操作的实现[问题描述] 当要在线性表顺序存储结构上的第i个位置上插入一个数据元素时,必须首先将线性表中第i个元素之后的所有数据元素依次后移一个位置,以便腾空一个位置;再把新元素插入到该位置上。
当要删除第i个数据元素时,也必须把第i个元素之后的所有数据元素前移一个位置。
[基本要求] 要求生成线性表时,可从键盘上读取元素,用顺序和链式存储结构实现存储;要求插入和删除之后输出线性表。
2. 约瑟夫环问题[问题描述] 设有n个人围坐在一圈,现在从某个人开始报数,数到m的人出列,接着从出列的下一个人开始重新报数,数到m的人又出现了;如此下去,直到所有人都出列为止,试设计确定他们出列次序序列的程序。
[基本要求] 选择单向循环链表作为存储结构,模拟报数过程,并且依次输出出列每个人的编号。
3. 一元多项式简单计算[问题描述] 设计一个一元多项式简单的计算器。
[基本要求] 一元多项式简单计算器的基本功能是:(1) 输入并建立多项式;(2) 输出多项式;(3) 两个多项式相加、相减、相乘,建立并输出多项式。
●实验要求(1) 认真分析题目。
(2) 进行算法设计。
(3) 编写程序代码(4) 上机调试程序。
(5) 保存和打印出程序的运行结果,并结合程序进行分析。
数据结构实验报告讲解

浙江师范大学实验报告学院:数理与信息工程学院专业:计算机科学与技术姓名:杨富生学号: 201531910137课程名称:数据结构指导教师:钟发荣实验时间: 2016-06-152016年6月15日实验一1.实验要求1.1掌握数据结构中线性表的基本概念。
1.2熟练掌握线性表的基本操作:创建、插入、删除、查找、输出、求长度及合并并运算在顺序存储结构上的实验。
2.实验内容2.1编写一个函数,从一个给定的顺序表A中删除元素值在x到y之间的所有元素,要求以较高效率来实现。
#include<stdio.h>typedef int elemtype;#define maxsize 10int del(int A[],int n,elemtype x,elemtype y){int i=0,k=0;while(i<n){if(A[i]>=x&&A[i]<=y)k++;elseA[i-k]=A[i];i++;}return(n-k);}void main(){int i,j;int a[maxsize];printf("输入%d个数:\n",maxsize);for(i=0;i<maxsize;i++)scanf("%d,",&a[i]);j=del(a,maxsize,1,3);printf("输出删除后剩下的数:\n");for(i=0;i<j;i++)printf("%d "\n,a[i]);}2.2试写一个算法,在无头结点的动态单链表上实现线性表插入操作INSERT(L,i,b)。
void Insert(Linklist &L,int i,elemtype x){if(!L){L=(Linklist)malloc(sizeof(Lnode));(*L).data=x;(*L).next=NULL;}else{if(i==1){s=(Linklist)malloc(sizeof(Lnode));s->data=x;s->next=L;L=s;}else{p=L;j=1;while(p&&j<i-1){j++;p=p->next;}if(p||j>i-1)return error;s=(Linklist)malloc(sizeof(Lnode));s->data=x;s->next=p->next;p->next=s;}}}2.3生成两个多项式PA和PB,求他们的和,输出“和多项式”。
北邮数据结构实验二八皇后问题

数据结构实验报告实验名称:学生姓名:班级:班内序号:学号:日期:一.实验描述: 利用栈结构实现八皇后问题。
二.八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是:在8*8的棋盘上放置8个皇后, 使其不能互相攻击, 即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
三.程序分析1.存储结构: 栈2.关键算法分析:a)比较函数: 比较某两个皇后是否在同一横、竖、斜线上。
行数:a和b。
列数:row[a]和row[b]。
主对角线数:(a+row[a])和(b+row[b])。
副对角线数:(a+7-row[a])和(b+7-row[b])。
b)八皇后实现(非递归):放置每一行的皇后时, 考虑其与已放好的之前行是否存在矛盾, 并作出相应的退栈、进栈或改变位置的反应。
放置完8行后, 计算下一个解。
当最后取得的解与第一个解重复时, 已取得全部解, 结束程序。
3.代码详细分析:#include<iostream>using namespace std;bool CompArray(int a[],int b[],int n)//用来比较两组解是否相等的函数{bool e=1;for(int i=0;i<n;i++){if(a[i]!=b[i])e=0;}return e;}class Stack //栈{public:Stack();void Push(int n);void Pop();bool Compare(int a,int b);void EightQueen();private:int row[8];//row[i]代表第i行皇后的列数是row[i], 因为八皇后不同行, 所以每行都有且只有一个皇后int top;};Stack::Stack() //置空栈{top=-1;}void Stack::Push(int n) //压栈函数{row[++top]=n; //int n进栈, top指针+1}void Stack::Pop() //退栈函数{top-=1; //top指针-1}bool Stack::Compare(int a,int b) //比较函数, 比较某两个皇后是否在同一行、列或对角线上{return row[a]==row[b]||(a+row[a])==(b+row[b])||(a+7-row[a])==(b+7-row[b]);} /*输入的行数a和b本来就不相等比较列数row[a]和row[b]是否相等比较主对角线数(a+row[a])和(b+row[b])是否相等比较副对角线数(a+7-row[a])和(b+7-row[b])是否相等bool输出0表示以上均不相等*/void Stack::EightQueen() //八皇后判断函数{int count=0; //计数量, 计解的个数int a[8]; //存储数组, 存储第一个解以便比较while(1) //控制每次进栈的大循环{Push(0);//为当前指针所指的下一位进栈0, 表示上一行皇后位置判断完成, 进入下一行判断loop:for(int j=0;j<top;j++)//将当前指针所在行与之前每一行进行对比, 以判断本行当前列是否可放置皇后的比较循环{if(Compare(top,j)!=0){row[top]++;//如果有任何一次比较的结论是不可放置, 本行的列数+1while(1)//如果列数+1之后超出8列, 则退栈, 给上一行列数加1, 如再超列再退栈, 以此类推{if(row[top]>7){Pop();row[top]++;}else break;}goto loop;//进行下一次比较循环}}if(top==7)//如果top=7, 说明已经判断完了第8行, 可以输出解{if(count==0)//用a[]记录第一个解{for(int i=0;i<8;i++){a[i]=row[i];}}else{if(CompArray(a,row,8)==1)break;//当再次求出的解与第一个解相同时, 说明已经输出了全部的解, 将不再输出}count++;//解的计数量+1cout<<"第"<<count<<"个解:"<<endl;//输出解for(int i=0;i<8;i++){cout<<"第"<<i+1<<"个皇后在第"<<i+1<<"行, 第"<<row[i]+1<<"列"<<endl;}cout<<endl;row[top]++;//本次求解后, 给第8行列数+1, 以进行下一次求解while(1)//超列则当前位列数置零, 退栈后列数+1{if(row[top]>7){row[top]=0;row[--top]++;}else break;}goto loop;//进入比较循环, 开始下一次求解}}}main(){Stack S1;S1.EightQueen();}a) 4.时间复杂度计算: (皇后数为n,解的个数为m)某一行取某个值时与之前每行比较: O(n)。
2023年408数据结构第二题

2023年408数据结构题目二:1. 题目描述:在2023年408数据结构考试中,第二题要求考生使用C++语言实现一个双向链表,包括双向链表的初始化、插入、删除、查找等基本操作,并且要求实现双向链表的倒序输出功能。
2. 解题思路:在解决这道题目时,我们首先需要了解什么是双向链表,双向链表是一种链表结构,每个节点包含两个指针,一个指向前一个节点,一个指向后一个节点。
双向链表的插入和删除操作比较灵活,可以在节点之间进行插入和删除操作。
我们可以通过使用C++语言来实现双向链表的结构,定义一个节点类来表示链表的节点,包含数据域和指针域,然后实现双向链表的初始化、插入、删除和查找操作。
3. 实现过程:我们需要定义一个节点类:```c++class Node {public:int data;Node *prev;Node *next;Node(int data) {this->data = data;this->prev = nullptr;this->next = nullptr;}};```我们可以定义一个双向链表类,包含双向链表的初始化、插入、删除和查找操作:```c++class DoublyLinkedList {private:Node *head;Node *tail;public:DoublyLinkedList() {head = nullptr;tail = nullptr;}void insert(int data) {Node *newNode = new Node(data); if (head == nullptr) {head = newNode;tail = newNode;} else {tail->next = newNode;newNode->prev = tail;tail = newNode;}}void delete(int data) {Node *current = head;while (current != nullptr) {if (current->data == data) {if (current == head) {head = current->next;head->prev = nullptr;} else if (current == tail) {tail = current->prev;tail->next = nullptr;} else {current->prev->next = current->next; current->next->prev = current->prev; }delete current;break;}current = current->next;}}Node* search(int data) {Node *current = head;while (current != nullptr) {if (current->data == data) {return current;}current = current->next;}return nullptr;}};```接下来,我们需要实现双向链表的倒序输出功能,可以通过递归或者栈来实现:```c++void reversePrint(Node *current) {if (current == nullptr) {return;}reversePrint(current->next);std::cout << current->data << " ";}```4. 总结:通过以上步骤,我们可以完成2023年408数据结构考试中第二题的要求,实现了双向链表的初始化、插入、删除、查找以及倒序输出功能。
数据结构实验指导书及其答案pdf

引言概述正文内容
1.实验环境配置
1.1硬件要求
计算机硬件配置要求
操作系统要求
附加硬件设备要求(如虚拟机等)
1.2软件要求
编程语言要求(如C/C++、Java等)开发环境配置(如IDE、编译器等)1.3实验库和工具
实验需要使用的库文件和工具
如何获取和配置实验库和工具
2.实验内容介绍
2.1实验目标和背景
数据结构实验的作用和意义
实验背景和相关应用领域介绍
2.2实验概述
实验内容的大致流程和步骤
实验中可能遇到的问题和挑战
2.3实验要求
对学生实验流程和实验结果的要求
实验过程中需要注意的事项和技巧
3.实验步骤
3.1实验准备
配置实验环境
获取实验所需数据和文件
3.2实验具体步骤
根据实验要求将数据结构知识应用到具体问题中根据实验要求实现相应的算法和数据结构
3.3实验示例代码
提供示例代码以供学生参考和学习
解析示例代码中的关键步骤和实现细节
4.实验答案
4.1实验题目
实验题目及相关说明
确定实验的具体要求和目标
4.2实验答案解析
对实验答案的具体实现进行解析
对实验中可能遇到的问题和错误进行分析和解决4.3实验答案示例
提供实验答案的示例代码
解析实验答案中的关键实现步骤和说明
5.实验总结
5.1实验成果评估
对学生实验成果进行评估
分析实验结果的优点和不足
5.2实验心得
学生对本次实验的收获和感想
学生对未来实验的建议和展望
总结。
数据结构实验报告(重邮)

数据结构实验日志实验题目:单链表的插入与删除实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。
实验要求:建立一个数据域定义为字符串的单链表,在链表中不允许有重复的字符串;根据输入的字符串,先找到相应的结点,后删除之。
实验主要步骤:1、分析、理解程序。
2、调试程序,并设计输入数据(如:bat,cat,eat,fat,hat,jat,lat,mat,#),测试程序的如下功能:不允许重复字符串的插入;根据输入的字符串,找到相应的结点并删除。
3、修改程序:(1)增加插入结点的功能。
(2)将建立链表的方法改为头插入法。
实验结果:Input#to end Please input Node-date:batInput#to end Please input Node-date:catInput#to end Please input Node-date:eatInput#to end Please input Node-date:#bat , cat , eat ,Delete Node<y/n>:yPlease input Delete-date : catbat , eat ,Please put any key to continue(1)头插入法建表该方法从一个空表开始,重复读入数据,生成新的结点,将读入的数据存放在新的结点的数据域中,然后将新结点插入到当前链表的表头上,直到读入结束标志符号为止。
数据结构实验日志实验题目:二叉树操作实验目的:掌握二叉树的定义、性质及存储方式,各种遍历算法。
实验要求:采用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作,求所有叶子及结点总数的操作。
实验主要步骤:1、分析、理解程序。
2、调试程序,设计一棵二叉树,输入完全二叉树的先序序列,用#代表虚结点(空指针),如ABD###CE##F##,建立二叉树,求出先序、中序和后序以及按层次遍历序列,求所有叶子及结点总数。
北京邮电大学 计算机学院 数据结构第二次实验报告

实验报告(2)姓名:学号:班级:日期:一、实验目的:掌握特殊线性表栈和队列的有关运算,熟悉栈和队列的存储结构的基本特点。
二、实验原理:完成特殊单链表-----栈和队列的运算。
具体:1、利用栈完成1个字符串的逆置运算;2、在一个循环队列中入队2元素的运算。
三、实验内容及要求:1、编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算,要求使用入栈和出栈运算来完成。
2、编写一个算法程序实现在一个循环队列中入队2个元素,要求先建立一个循环队列,元素个数为4个,然后在循环队列的末尾加入2个元素。
要求:请同学把步骤、调试好的程序及存在的问题写在下面。
第一题:步骤:首先创建一个空栈 ,然后提示用户输入一个字符串,依次读取字符串的每个字符并入栈 ,再依次取栈顶元素并出栈 ,便可得到原字符串的逆置。
第一题实验程序代码:#include <stdio.h>#define Stack_Size 50//数组大小定义typedef char DataType;typedef struct{DataType elem[Stack_Size];int top;}SeqStack;//栈的结构定义SeqStack *InitStack();//栈的创建函数int StackEmpty(SeqStack *S);//判断栈是否为空int StackFull(SeqStack *S);//判断栈是否为满void Push(SeqStack *S,DataType x);//元素入栈DataType Pop(SeqStack *S);//元素出栈void playdata(SeqStack *S);//打印输出栈中的元素int main(){SeqStack *S;char x;S=InitStack();if(S==NULL)return 0;printf("请输入一个字符串,以回车键结束:\n");//打印提示语x=getchar();while(x!='\n'){Push(S,x);x=getchar();}if(!StackEmpty(S))//判断字符串是否为空{printf("该字符串的逆序是:\n");playdata(S);}elseprintf("该字符串为空!\n");system("pause");return 0;}SeqStack *InitStack()//栈的创建函数{SeqStack *S;S=(SeqStack*)malloc(sizeof(SeqStack));if(S==NULL)return NULL;else{S->top=-1;return S;}}int StackEmpty(SeqStack *S)//判断栈是否为空{return S->top==-1;}int StackFull(SeqStack *S)//判断栈是否为满{return S->top==Stack_Size-1;}void Push(SeqStack *S,DataType x)//元素入栈{S->elem[++S->top]=x;}DataType Pop(SeqStack *S)//元素出栈{return S->elem[S->top--];}void playdata(SeqStack *S)//打印输出栈中的元素{int i=0;for(i=S->top;i>=0;i--){printf("%c",S->elem[i]);}printf("\n");}第二题:步骤:首先创建一个循环队列,接着在循环队列中入队四个元素,接着提示用户输入2个元素,再入队,再将入队后的队列元素从队头到队尾打印出来,程序结束。
数据结构(第二版)课后习题答案

数据结构(第二版)课后习题答案第一章:数据结构概述数据结构是计算机科学中非常重要的一个概念,它用于组织和管理计算机内部存储的数据。
数据结构的设计直接影响到程序的运行效率和对真实世界问题的建模能力。
第二版的《数据结构》教材旨在帮助读者更好地理解和应用数据结构。
为了提高学习效果,每章节后都附有一系列习题。
本文将为第二版《数据结构》教材中的部分习题提供详细的答案和解析。
第二章:线性表2.1 顺序表习题1:请问如何判断顺序表是否为空表?答案:当顺序表的长度为0时,即为空表。
解析:顺序表是用一块连续的内存空间存储数据元素的线性结构。
当顺序表中没有元素时,长度为0,即为空表。
习题2:如何求顺序表中第i个元素的值?答案:可以通过访问顺序表的第i-1个位置来获取第i个元素的值。
解析:顺序表中的元素在内存中是连续存储的,通过下标访问元素时,需要将下标减1,因为数组是从0开始编号的。
2.2 链表习题1:请问链表中的结点包含哪些信息?答案:链表的结点一般包含两部分信息:数据域和指针域。
解析:数据域用于存储数据元素的值,指针域用于存储指向下一个结点的指针。
习题2:如何删除链表中的一个结点?答案:删除链表中的一个结点需要将其前一个结点的指针指向其后一个结点,然后释放被删除结点的内存空间。
解析:链表的删除操作相对简单,只需要通过修改指针的指向即可。
但需要注意释放被删除结点的内存空间,防止内存泄漏。
第三章:栈和队列3.1 栈习题1:如何判断栈是否为空?答案:当栈中没有任何元素时,即为空栈。
解析:栈是一种先进后出(Last In First Out,LIFO)的数据结构,栈顶指针指向栈顶元素。
当栈中没有元素时,栈顶指针为空。
习题2:请问入栈和出栈操作的时间复杂度是多少?答案:入栈和出栈操作的时间复杂度均为O(1)。
解析:栈的入栈和出栈操作只涉及栈顶指针的改变,不受栈中元素数量的影响,因此时间复杂度为O(1)。
3.2 队列习题1:请问队列可以用哪些方式实现?答案:队列可以用数组或链表来实现。
数据结构第2版习题答案

数据结构第2版习题答案第1章:引言数据结构是计算机科学中非常重要的一个领域,它关注如何以高效的方式组织和存储数据,以及如何在数据集合中进行操作和处理。
本章将回答《数据结构第2版》中的习题,帮助读者更好地理解和掌握数据结构。
第2章:算法分析习题1:算法复杂度问题描述:给定一个算法中的递归函数,分析其时间复杂度。
解答:对于递归算法的时间复杂度分析,可以使用递归树或者递推关系式来求解。
根据习题中给出的递归函数具体形式,我们可以推导出其递归关系式,并通过求解递推关系式确定时间复杂度。
习题2:渐进符号问题描述:给定两个函数f(n)和g(n),证明f(n)的渐进复杂度小于等于g(n)的渐进复杂度。
解答:为了证明f(n)的渐进复杂度小于等于g(n)的渐进复杂度,我们需要使用大O符号进行形式化的证明。
通过定义和性质的证明,可以得出结论。
第3章:线性表习题3:线性表的实现问题描述:实现一个线性表的数据结构,并给出相关操作的算法。
比如插入元素、删除元素、查找元素等。
解答:一个线性表可以通过数组或链表来实现。
我们可以定义一个包含元素和相关操作的类来表示线性表。
在插入、删除、查找元素等操作中,可以通过遍历或者索引等方式来实现。
习题4:线性表的应用问题描述:举例介绍线性表的应用场景,并分析其对应的实现方法和复杂度。
解答:线性表的应用场景非常广泛,比如数组、链表、队列、栈等。
我们可以通过具体的案例,如存储学生成绩、处理任务队列、实现表达式求值等,来说明线性表的应用和对应的实现方法。
第4章:栈和队列习题5:栈和队列的实现问题描述:实现一个栈和队列的数据结构,并给出相关操作的算法。
解答:栈和队列可以通过数组或链表来实现。
我们可以定义相应的类来表示栈和队列,并实现相关操作,如入栈、出栈、入队、出队等。
习题6:栈和队列的应用问题描述:举例介绍栈和队列的应用场景,并分析其对应的实现方法和复杂度。
解答:栈和队列的应用非常广泛,比如表达式求值、括号匹配、图的深度优先搜索等。
北京信息科技大学 数据结构 实验二 链栈、循环队列和计算器的操作

实验报告课程名称数据结构实验项目链栈、循环队列和计算器的操作实验仪器计算机系别计算机学院学院专业班级/学号学生姓名实验日期成绩指导教师一、实验目的(1)熟悉链栈的操作方法(2)熟悉循环队列的操作方法(3)利用栈的特点来编写简易计算器(4)了解各自的优缺点。
二、实验内容(1)用链栈实现数据的增、删、查功能(2)用循环队列实现数据的增、删、查等功能(3)用栈的知识来编写简易计算器三、实验课时4课时四、实验步骤1.仔细分析并理解数据结构这本书上提供的部分程序伪代码2.根据所给的代码编写出主函数和一些需要用到的函数3.将伪代码翻译为程序能用的代码4.充分理解每段代码的含义以及它所起到的作用5. 编译调试,纠正错误并分析出错的原因6. 运行并测试五、程序源代码1.链栈:#include<stdio.h>#include<stdlib.h>typedef struct SNode{int data;struct SNode *next;}SNode,*Stack;typedef struct{Stack top;int length;}SqStack;//定义链式栈的结构体int InitStack(SqStack & S){S.top=NULL;S.length=0;return 0;}//初始化链式栈int Push(SqStack &S,int e){Stack p;p=(Stack)malloc(sizeof(SNode));if(!p)exit(0);p->data=e;p->next=S.top;S.top=p;S.length++;return 0;}//插入元素eint Pop(SqStack & S){if(!S.top)return 0;else{Stack q;q=S.top;S.top=S.top->next;--S.length;free(q);}return 0;}//删除栈顶元素eint GetTop(SqStack &S){if(!S.top)return 0;else{printf("返回栈顶元素%5d\n",S.top->data);}return 0;}//返回栈顶元素int PrintStack(SqStack &S){Stack p;printf("\n链式队列中的元素");p=S.top;if(S.top!=NULL){while(p!=NULL){printf("%5d",p->data);p=p->next;}}elseprintf("队列为空\n");printf("\n");return 0;}//遍历链式栈int ClearStack(SqStack & S){S.top=NULL;printf("已置空链式栈");printf("\n");return 0;}//置空链式栈void main(){SqStack S;int e,m;InitStack(S);for(;;){printf("1.插入元素;2.删除元素;3.栈顶元素;4.结束运行\n\n");printf("选择: ");scanf("%d",&m);printf("\n");switch(m){case 1 : printf("插入元素:");scanf("%d",&e);Push(S,e);PrintStack(S);printf("\n");break;case 2 : Pop(S);PrintStack(S);printf("\n");break;case 3 : GetTop(S);printf("\n");break;case 4 : ClearStack(S);printf("\n");break;default : printf("输入指令有误!");break;}}}2.循环队列:#include<stdio.h>#include<stdlib.h>#define MAXQSIZE 100 //最大队列长度#define OK 1#define OVERFLOW -2#define ERROR 0typedef int QElemType;typedef int Status;typedef struct{QElemType * base; //初始化的动态分配存储空间int front; //头指针,若队列不空,指向队列头元素int rear; //尾指针,若队列不空,指向队列尾元素的下一个的位置}SqQueue;Status InitQueue (SqQueue &Q){// 构造一个空队列QQ.base=(QElemType * ) malloc (MAXQSIZE * sizeof (QElemType));if(!Q.base) exit (OVERFLOW);//存储分配失败Q.front=Q.rear=0;return OK;}int QueueLength (SqQueue &Q){int x=0;x=(Q.rear-Q.front+MAXQSIZE) % MAXQSIZE;printf("该队列长为:%d",x);return 0;}Status EnQueue (SqQueue &Q, QElemType e){//插入元素e为Q的新的队尾元素int y=0;if((Q.rear+1) % MAXQSIZE == Q.front ) return ERROR;//队列满if(e==0){printf("请输入要插入的值:");scanf("%d",&y);Q.base[Q.rear]=y;Q.rear=(Q.rear + 1) % MAXQSIZE;}else{Q.base[Q.rear]=e;Q.rear=(Q.rear + 1) % MAXQSIZE;}return OK;}Status DeQueue (SqQueue &Q, QElemType e){//若队列不空,则删除Q的队头元素,用e返回其值,并返回OK;否则返回ERRORif(Q.front == Q.rear) return ERROR;e=Q.base[Q.front];Q.front=(Q.front + 1) % MAXQSIZE;return OK;}int Put(SqQueue &Q,int n){for(int i=0;i<n;i++){scanf("%d",&Q.base[i]);EnQueue(Q,Q.base[i]);}return OK;}void Out(SqQueue &Q,int n){printf("该队列为:");for(int i=0;i<n;i++)printf("%d ",Q.base[i]);}int main(){int i=0,n=0,a=0,e=0;SqQueue Q;InitQueue(Q);printf("请指定该队列有多少个元素:");scanf("%d",&n);printf("请输入这%d个元素:",n);Put(Q,n);Out(Q,n);for(;;){printf("\n请输入以下指令来进行操作:1.插入 2.删除 3.清屏 4.长度 5.结束\n");scanf("%d",&a);switch(a){case 1 : EnQueue(Q,e);n++;Out(Q,n);break;case 2 : DeQueue(Q,e);n--;Out(Q,n);break;case 3 : system("cls");break;case 4 : QueueLength(Q);break;case 5 : return 0;default : printf("输入指令有误!");break;}}return 0;}3.计算器:#include<stdio.h>#include<stdlib.h>typedef struct SNode_T{char data;struct SNode_T *next;}SNode_T;typedef struct SNode_N{float data;struct SNode_N *next;}SNode_N;typedef struct SqStack_T{int length;SNode_T *top;}SqStack_T;typedef struct SqStack_N{int length;SNode_N *top;}SqStack_N;void InitStack_T(SqStack_T *S){S->top=NULL;S->length=0;}void InitStack_N(SqStack_N *S){S->top=0;S->length=0;}int Push_T(SqStack_T *S,char e){SNode_T *p;p=(SNode_T *)malloc(sizeof(SNode_T)); if(!p) exit(0);p->data=e;p->next=S->top;S->top=p;S->length++;return 1;}int Push_N(SqStack_N *S,float e){SNode_N *p;p=(SNode_N *)malloc(sizeof(SNode_N)); if(!p) exit(0);p->data=e;p->next=S->top;S->top=p;S->length++;return 1;}char Pop_T(SqStack_T *S){char e;SNode_T *p;if(S->top==NULL) return -1;p=S->top;e=p->data;S->top=p->next;S->length--; free(p);return e;}float Pop_N(SqStack_N *S){float e;SNode_N *p;if(S->top==NULL) return -1;p=S->top;e=p->data;S->top=p->next;S->length--; free(p);return e;}float Operate(float a,char c,float b){float s;switch(c){case '+':s=a+b; break;case '-':s=a-b; break;case '*':s=a*b; break;case '/':if(b!=0) s=a/b;elseprintf("Input error!");break;}return s;}int GetTop_N(SqStack_N *S){int e;SNode_N *p;if(S->top==NULL) return -1;p=S->top;e=p->data;return e;}char GetTop_T(SqStack_T *S){char e;SNode_T *p;if(S->top==NULL) return -1;p=S->top;e=p->data;return e;}int Suffix(char c,char s[]){int i=0;while(s[i]!=c)i++;return i;}char Precede(char a,char b){int p,q;char m[9]="+-*/()=";char n[9][9]={">><<<>>",">><<<>>",">>>><>>",">>>><>>","<<<<<= ",">>>>>>","<<<< ="};p=Suffix(a,m);q=Suffix(b,m);return(n[p][q]);}int In(char c){if(c!='+'&&c!='-'&&c!='*'&&c!='/'&&c!='('&&c!=')'&&c!='=') return 1;else return 0;}void main(){char c,x,theta;int a,b,i;SqStack_T OPTR;SqStack_N OPND;InitStack_T(&OPTR);Push_T(&OPTR,'=');InitStack_N(&OPND);for(;;){printf("请输入一个正确的表达式 :\n");c=getchar();while(c!='='||GetTop_T(&OPTR)!='='){if(In(c)){i=c-48;Push_N(&OPND,i);c=getchar();}elseswitch(Precede(GetTop_T(&OPTR),c)){case '<':Push_T(&OPTR,c); c=getchar();break;//栈顶元素优先权低case '=':x=Pop_T(&OPTR); c=getchar();break;//脱括号并接受下一个字符case '>'://退栈并将运算结果入栈theta=Pop_T(&OPTR);b=Pop_N(&OPND);a=Pop_N(&OPND);Push_N(&OPND,Operate(a,theta,b));break;}}printf("运算结果是: %d\n",GetTop_N(&OPND));}六、实验截图(1)链栈:1.插入数据:2.删除数据:3.查找栈顶:(2)循环队列:初始化:1.创建队列:2.插入:3.队列长:4.删除:(3)计算器:七、实验心得1.通过这次实验让我充分了解了以前虽然学过但其实还不是很理解的顺序表和单链表的一些具体操作和原理。
数据结构实验报告利用栈结构实现八皇后问题

数据结构实验报告实验名称:实验二——利用栈结构实现八皇后问题学生姓名:班级:班内序号:学号:日期: 2013年11月21日1.实验要求(1)实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力(2)实验内容利用栈结构实现八皇后问题。
八皇后问题19世纪著名的数学家高斯于1850年提出的。
他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。
请设计算法打印所有可能的摆放方法。
①可以使用递归或非递归两种方法实现②实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线。
(3)代码要求①必须要有异常处理,比如删除空链表时需要抛出异常;②保持良好的编程的风格:代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能③递归程序注意调用的过程,防止栈溢出2. 程序分析存储结构栈(递归):关键算法分析(1)递归void SeqStack<T>::PlaceQueen(int row) 其他说明:由于输出显示时对话框有限,而程序结果比较多,占用空间大,最后只显示60种到92种,这需要适当的设置对话框,设置步骤为:属性—屏幕缓冲区高度设为相对大些的值(1000或其他),即可显示所有结果。
也可适当完善代码将结果输出到一个文档里,便于观察分析。
3. 程序运行结果实验流程图:实验结果:4. 总结总结:这次实验让我更好地掌握了栈思想以及一维数组等等知识,以及一些书本上没有的东西,让我学会了运用递归算法去解决一些复杂的问题改进:不仅可以设计放置八皇后,也可以是9皇后,10皇后,只要修改N ;也可以尝试采开始输入n判断是否满行 q[k]=i ans++YN输出结果 判断位置是否符合要求N Yrow++用二维数组的思想来实现。
南航专接本《数据结构》实验报告2

《数据结构》实验报告班级:学号: 姓名:实验名称:实验二二叉树操作实验时间:. 实验地点:指导教师:实验目的与要求:①要求采用二叉链存储结构,编写程序完成二叉树的建立,输出先序、中序及后序遍历二叉树的遍历序列,清楚各种递归遍历算法中递归调用语句的位置和功能。
②求二叉树的结点总个数、叶结点个数和符合指定条件的结点个数(比如,二叉树结点的值为整数,求该树中值为偶数的结点的个数)的操作。
实验内容:采用二叉树链表作为存储结构,完成二叉树的建立,先序、中序和后序以及按层次遍历的操作,求所有叶子及结点总数的操作。
二叉树以链式结构表示,主程序以菜单方式的用户界面。
算法设计(流程图):算法实现程序(源代码):(见源程序文件,附在本文后)上机调试情况(调试数据、调试过程中遇到的问题及解决方法):问题1:由于不懂递归算法的使用方法,导致做实验时不知从何下手,后来详细阅读了相关资料以后明白了递归算法的思想,实验得以继续进行。
问题2:在进行创建树时,以“,”表示虚节点,但是程序不能正常运行,查阅相关资料后,用“#”替换,问题得以解决。
测试数据和输出结果:建立二叉树的数据123##45##6##7##先序遍历的结果:1234567中序遍历的结果:3254617后序遍历的结果:3564271打印深度、结点数、叶子数:深度=4 结点数=7 叶子数=4附:源代码#include <stdio.h>#include <string.h>#include <stdlib.h>#define Max 20typedef struct node{char data;struct node *lchild;struct node *rchild;}BTNode;typedef BTNode *BTree;int NodeNum,leaf;BTree CreatBTree(void);void Preorder(BTree T);void Inorder(BTree T);void Postorder(BTree T);int TreeDepth(BTree T);void main(){BTree root;int i,deep;printf("请输入完全二叉树的先序序列,用#代表虚结点:\n");root=CreatBTree();do{printf("\n==============================================");printf("\n** 1:先序遍历**");printf("\n** 2:中序遍历**");printf("\n** 3:后序遍历**");printf("\n** 4:深度、结点数、叶子数**");printf("\n** 0:退出**");printf("\n==============================================");printf("\n请输入数字:");scanf("%d",&i);//输入菜单序号while(i!=0&&i!=1&&i!=2&&i!=3&&i!=4){printf("只能输入0-4的整数!请重新输入:");scanf("%d",&i);}switch(i){case 1:printf("先序遍历结果为:");Preorder(root);break;case 2:printf("中序遍历结果为:");Inorder(root);break;case 3:printf("后序遍历结果为:");Postorder(root);break;case 4:deep=TreeDepth(root);printf("深度=%d 结点数=%d 叶子数=%d",deep,NodeNum,leaf);break;}}while(i!=0);}BTree CreatBTree(void)//创建树{BTree T;char ch;ch=getchar();if(ch=='#')return(NULL);else{T=(BTNode *)malloc(sizeof(BTNode));T->data=ch;T->lchild=CreatBTree();T->rchild=CreatBTree();return(T);}}void Preorder(BTree T) //先序遍历算法{if(T){printf("%c",T->data);//访问结点Preorder(T->lchild);//先序遍历左子树Preorder(T->rchild);//先序遍历右子树}}void Inorder(BTree T)//中序遍历算法{if(T){Inorder(T->lchild);//中序遍历左子树printf("%c",T->data);//访问结点Inorder(T->rchild);//中序遍历右字树}}void Postorder(BTree T)//后序遍历算法{if(T){Postorder(T->lchild);Postorder(T->rchild);printf("%c",T->data);}}int TreeDepth(BTree T)//后序遍历求二叉树的深度,结点数和叶子数{int l_deep,r_deep,max;if(T){l_deep=TreeDepth(T->lchild);//求左深度r_deep=TreeDepth(T->rchild);//求右深度max=l_deep>r_deep?l_deep:r_deep;//取左右深度的最大值NodeNum=NodeNum+1;//求结点数if(l_deep==0&&r_deep==0){leaf=leaf+1;}return(max+1);}elsereturn(0);}。
北邮数据结构实验第二次实验图

数据结构实验报告1.实验要求(1)实验目的通过选择下面5个题目之一进行实现,掌握如下内容:掌握图基本操作的实现方法了解最小生成树的思想和相关概念了解最短路径的思想和相关概念学习使用图解决实际问题的能力(2)实验内容根据图的抽象数据类型的定义,使用邻接矩阵或邻接表实现一个图。
图的基本功能:1、图的建立2、图的销毁3、深度优先遍历图4、广度优先遍历图5、使用普里姆算法生成最小生成树6、使用克鲁斯卡尔算法生成最小生成树7、求指定顶点到其他各顶点的最短路径8、其他:比如连通性判断等自定义操作编写测试main()函数测试图的正确性2. 程序分析存储结构图:(1)带权值的无向图V09 6V1 2 V2(2)带权值的有向图V063 9 4V1 2 V2关键算法分析(1)深度优先遍历int visited[MAXSIZE]={false};template<class T>void MGraph<T>::DFS(int v){cout<<vertex[v];visited[v]=true;for(int j=0;j<vNum;j++)if(arc[v][j]==1&&!visited[j])DFS(j);}时间复杂度:O(n²)(2)广度优先遍历int queue[MAXSIZE];int f=0,r=0;cout<<vertex[v];visit[v]=true;queue[++r]=v;while(f!=r){v=queue[++f];for(int j=0;j<vNum;j++){if(arc[v][j]==1&&!visit[j]){cout<<vertex[j];visit[j]=true;queue[++r]=j;}时间复杂度:O(n²)(3)普利姆算法int adjvex[MAXSIZE];int lowcost[MAXSIZE];int MAX=10000;template<class T>int mininum(MGraph<T> G,int a[]){int min=MAX;int k=0;for(int i=0;i<;i++){if(a[i]!=0&&a[i]<min)romV=i;E[k].endV=j;E[k].weight=[i][j];k++;}for(i=0;i<;i++){for(j=i+1;j<;j++)if(E[i].weight>E[j].weight){VEdge t=E[i];E[i]=E[j];E[j]=t;}}}const int MAX_VERTEXT=20;template<class T>void MGraph<T>:: Kruskal(VEdge E[],int n,int e){int vset[MAX_VERTEXT];for(int i=0;i<n;i++) vset[i]=i;romV,n=E[j].endV;int sn1=vset[m]; 程序运行结果(1)流程图:初始化带权值的无向图深度优先遍历,广度优先遍历用普利姆算法求最小生成树用克鲁斯卡尔算法求最小生成树初始化带权值的有向图用Floyd算法求任意两点间最短路径,并判断连通性删除图(2)本程序所用的图带权值的无向图V09 6V1 2 V2带权值的有向图V063 9 4V1 2 V2(3)程序结果4. 总结(1)遇到的问题:私有数据访问权的问题,在编程时应该注意(2)心得体会:通过这次实验,我掌握了图基本操作的实现方法,了解最小生成树的思想和相关概念,了解最短路径的思想和相关概念等等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
理工学院实验报告
系部计算机系班级学号
课程名称数据结构实验日期
实验名称链表的基本操作成绩
实验目的:
(1)掌握线性表的链式存储结构的特点;
(2)掌握线性表的基本操作:初始化、插入、删除、查找数据元素等运算在链式存储结构上的实现。
实验条件:计算机一台,vc++6.0
实验容与算法思想:
容:
建立一有序的链表,实现下列操作:
1.把元素x插入表中并保持链表的有序性;
2.查找值为x的元素,若找到将其删除;
3.输出表中各元素的值。
算法思想:先创建并初始化一个顺序表(void init_linklist(LinkList)),通过循环,输入一串数据void CreateFromTail(LinkList L);创建主函数;编写算法,完成子函数(查找locate,插入insList,删除DelList,输出output)模块;调用子函数,完成实验要求
运行结果:
附:源程序:
#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
typedef char ElemType;
typedef struct Node
{
ElemType data;
struct Node* next;
}Node,*LinkList;
void init_linklist(LinkList *l)
{
*l=(LinkList)malloc(sizeof(Node));
(*l)->next=NULL; }
void CreateFromTail(LinkList L)
{ Node *r, *s;
char c;
int flag =1;
r=L;
while(flag)
{
c=getchar();
if(c!='$')
{
s=(Node*)malloc(sizeof(Node));
s->data=c;
r->next=s;
r=s;
}
else
{
flag=0;
r->next=NULL;
}
}
}
Node *Locate( LinkList L,ElemType key) {
int k;
Node *p;
k=1;
p=L->next;
while (p!=NULL)
{
if (p->data!=key)
{p=p->next; k++;}
else
break;
}
printf("查询的元素的位置为:");
printf("%d\n",k-1);
return p;
}
void InsList(LinkList L,int e)
LinkList p=L->next,q=L,s;
if(p->next==NULL)
{
printf("这是一个空链表\n");
}
else
{
while(p&&(p->data<=e))
{
q=p;
p=p->next;
}
if(p&&(p->data>=e))
{
s=(LinkList)malloc(sizeof(Node)); s->data=e;
s->next=p;
q->next=s;
}
else
{
s=(LinkList)malloc(sizeof(Node));
s->data=e;
s->next=NULL;
q->next=s;
}
}
int DelList(LinkList L,ElemType key)
{
Node *p,*pt;
p=L->next;
pt=p->next;
if(p->data==key)
{
L->next=pt;
free(p);
}
else while(pt!=NULL)
{
if(pt->data!=key)
{
pt=pt->next;
p=p->next;
}
else
{
p->next=pt->next;
free(pt);
break;
}
}
if(pt==NULL)printf("无该元素\n");
else printf("该元素已删除,删除后的排序为:\n");
return 1; }
void output(LinkList L)
Node *p;
p=L->next;
while(p!=NULL)
{
printf("%2c",p->data);
p=p->next;
}
}
void main()
{
LinkList L;
ElemType m,n,a;
init_linklist(&L);
printf("请输入您要录入的元素以$结束:\n"); CreateFromTail(L);
output(L);
printf("\n");
printf("请输入您要查询的元素:\n");
getchar();
n=getchar();
Locate(L,n);
printf("请输入您要插入的元素:\n");
getchar();
m=getchar();
InsList(L, m);
output(L);
printf("\n");
printf("请输入您要删除的元素:\n"); getchar();
a=getchar();
DelList(L,a);
output(L);
printf("\n");
}。