严蔚敏版数据结构第三章.
数据结构(严蔚敏)精第3章PPT课件
ppt精选版
10
二、栈的主要操作 1.初始化栈：InitStack(&S)
将栈S置为一个空栈(不含任何元素)。
2.进栈：PUSH(&S,X)
将元素X插入到栈S中，也称为 “入栈”、 “插入”、 “压 入”。
3.出栈： POP(&S，&e)
删除栈S中的栈顶元素，也称为”退栈”、 “删除”、 “弹出”。
或简单定义如下：
#define M 100 int s[M]; int top;
ppt精选版
16
图3.2 顺序栈中的进栈和出栈
Top指向栈顶元素 初态：top=-1; 空栈，栈中无元素， 进栈：top=top+1; s[top]=x; 退栈：取s[top]; top=top-1; 栈满：top=M-1;栈溢出（上溢），不能再进栈（错误状 态） top=-1时不能退栈，下溢（ppt精正选版常状态，常作控制条件17）
ppt精选版
两种存储结构中的实现都不难，但应该对它
们了如指掌，特别要注意它们的基本操作实
现时的一些特殊情况，如栈满和栈空、队满
和队空的条件以及它们的描述方法。本章要
求必须完成的算法设计题为：3.15，3.17，
3.19，3.22， 3.27 ,3.28，3.30，3.31，3.32。
其中前4个主要是练习栈的应用，后4个主要
插入：最先放入栈中元素在栈底，最后放入的元素在栈顶； 删除：最后放入的元素最先删除，最先放入的元素最后删除。 栈是一种后进先出(Last In First Out)的线性表，简称为LIFO 表。
ppt精选版
8
出栈 栈顶
an
进栈
出栈
进栈
…
严蔚敏 数据结构课后习题及答案解析
第一章绪论一、选择题1.组成数据的基本单位是（）（A）数据项（B）数据类型（C）数据元素（D）数据变量2.数据结构是研究数据的（）以及它们之间的相互关系。
（A）理想结构，物理结构（B）理想结构，抽象结构（C）物理结构，逻辑结构（D）抽象结构，逻辑结构3.在数据结构中，从逻辑上可以把数据结构分成（）（A）动态结构和静态结构（B）紧凑结构和非紧凑结构（C）线性结构和非线性结构（D）内部结构和外部结构4.数据结构是一门研究非数值计算的程序设计问题中计算机的（①）以及它们之间的（②）和运算等的学科。
①（A）数据元素（B）计算方法（C）逻辑存储（D）数据映像②（A）结构（B）关系（C）运算（D）算法5.算法分析的目的是（）。
（A）找出数据结构的合理性（B）研究算法中的输入和输出的关系（C）分析算法的效率以求改进（D）分析算法的易懂性和文档性6.计算机算法指的是（①）,它必须具备输入、输出和（②）等5个特性。
①（A）计算方法（B）排序方法（C）解决问题的有限运算序列（D）调度方法②（A）可执行性、可移植性和可扩充性（B）可行性、确定性和有穷性（C）确定性、有穷性和稳定性（D）易读性、稳定性和安全性二、判断题1.数据的机内表示称为数据的存储结构。
（）2.算法就是程序。
（）3.数据元素是数据的最小单位。
（）4.算法的五个特性为：有穷性、输入、输出、完成性和确定性。
（）5.算法的时间复杂度取决于问题的规模和待处理数据的初态。
（）三、填空题1.数据逻辑结构包括________、________、_________ 和_________四种类型,其中树形结构和图形结构合称为_____。
2.在线性结构中,第一个结点____前驱结点,其余每个结点有且只有______个前驱结点；最后一个结点______后续结点,其余每个结点有且只有_______个后续结点。
3.在树形结构中,树根结点没有_______结点,其余每个结点有且只有_______个前驱结点；叶子结点没有________结点,其余每个结点的后续结点可以_________。
数据结构(c语言版)_严蔚敏版_第3章_栈和队列_信大(第3讲)
3.2.1 栈的顺序存储结构及实现 两栈共享空间
0 1 2 ……
S-1
a1 a 2 … ai
top1
top1
bj … … b2 b1
top2 top1= -1
什么时候栈1为空？
3.2.1 栈的顺序存储结构及实现 两栈共享空间
0 1 2 ……
S-1
a 1 a2 … ai
top1
什么时候栈1为空？ 什么时候栈2为空？
栈的顺序存储结构简称为顺序栈，它是运算受限 的线性表。因此，可用数组来实现顺序栈。因为栈底 位置是固定不变的，所以可以将栈底位置设置在数组 的两端的任何一个端点；栈顶位置是随着进栈和退栈 操作而变化的，故需用一个整型变量top
定义：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元 素，同时附设指针top指示栈顶元素在顺序栈中的位置。
（4）取栈顶元素操作 取出栈顶元素：先判断栈是否为空，不为 空，则将栈顶元素值取出。 出栈和取栈顶值是不同的。
3.2.1 栈的顺序存储结构及实现 （5）判栈空操作
看栈顶和栈底是否相等。 （6）置空操作 栈顶和栈底相等
3.2.1 栈的顺序存储结构及实现 两栈共享空间
在一个程序中需要同时使用具有相同数据类型的 两个栈，如何顺序存储这两个栈？ 解决方案1：
3.2.2 栈的链式存储结构及实现
链栈：栈的链接存储结构 如何改造链表实现栈的链接存储？
head
a1
a2
an
将哪一端作为栈顶？ 将链头作为栈顶，方便操作。 链栈需要加头结点吗？ 链栈不需要附设头结点。
栈的链式存储结构称为链栈，它是运算是受限的单链表，插入和删除操作仅限制在表 头位置上进行.由于只能在链表头部进行操作，故链表没有必要像单链表那样附加头 结点。栈顶指针就是链表的头指针。
严蔚敏数据结构课后习题及答案解析
严蔚敏数据结构课后习题及答案解析数据结构课程是计算机科学与技术专业中非常重要的一门基础课程，对于学习者来说，课后习题的巩固和答案解析是学习的重要辅助材料。
本文将针对严蔚敏老师所著的《数据结构（C语言版）》中的课后习题及答案解析进行介绍和总结。
1. 第一章：绪论（略）2. 第二章：线性表（略）3. 第三章：栈和队列3.1 课后习题3.1.1 课后习题一：给定一个整数序列，请设计一个算法，其中删除整数序列中重复出现的元素，使得每个元素只出现一次。
要求空间复杂度为O(1)。
3.1.2 课后习题二：使用栈操作实现一个队列（其中队列操作包括入队列和出队列）。
3.2 答案解析3.2.1 答案解析一：我们可以使用双指针法来实现这一算法。
设定两个指针，一个指向当前元素，另一个指向当前元素的下一个元素。
比较两个元素是否相等，如果相等，则删除下一个元素，并移动指针。
如果不相等，则继续移动指针。
这样，当指针指向序列的最后一个元素时，算法结束。
空间复杂度为O(1)，时间复杂度为O(n)。
3.2.2 答案解析二：使用两个栈来实现一个队列。
一个栈用于入队列操作，另一个栈用于出队列操作。
当需要入队列时，将元素直接入栈1。
当需要出队列时，判断栈2是否为空，如果为空，则将栈1中的元素逐个弹出并压入栈2中，然后从栈2中弹出栈顶元素。
如果栈2非空，则直接从栈2中弹出栈顶元素。
这样，就可以实现使用栈操作来实现队列操作。
4. 第四章：串（略）5. 第五章：数组和广义表（略）6. 第六章：树和二叉树（略）7. 第七章：图（略）通过对严蔚敏老师所著《数据结构（C语言版）》中的课后习题及答案解析的介绍，可以帮助学习者更好地理解和掌握数据结构这门课程的知识内容。
课后习题不仅可以帮助巩固所学知识，更加于提升学习者的能力和应用水平。
希望本文对于学习者们有所帮助。
（文章结束）。
严蔚敏《数据结构(c语言版)习题集》答案第三章 栈与队列
第三章栈与队列3.15typedef struct{Elemtype *base[2];Elemtype *top[2];}BDStacktype; //双向栈类型Status Init_Stack(BDStacktype &tws,int m)//初始化一个大小为m的双向栈tws{tws.base[0]=(Elemtype*)malloc(sizeof(Elemtype));tws.base[1]=tws.base[0]+m;tws.top[0]=tws.base[0];tws.top[1]=tws.base[1];return OK;}//Init_StackStatus push(BDStacktype &tws,int i,Elemtype x)//x入栈,i=0表示低端栈,i=1表示高端栈{if(tws.top[0]>tws.top[1]) return OVERFLOW; //注意此时的栈满条件if(i==0) *tws.top[0]++=x;else if(i==1) *tws.top[1]--=x;else return ERROR;return OK;}//pushStatus pop(BDStacktype &tws,int i,Elemtype &x)//x出栈,i=0表示低端栈,i=1表示高端栈{if(i==0){if(tws.top[0]==tws.base[0]) return OVERFLOW;x=*--tws.top[0];}else if(i==1){if(tws.top[1]==tws.base[1]) return OVERFLOW;x=*++tws.top[1];}else return ERROR;return OK;}//pop3.16void Train_arrange(char *train)//这里用字符串train表示火车,'H'表示硬席,'S'表示软席{p=train;q=train;InitStack(s);while(*p){if(*p=='H') push(s,*p); //把'H'存入栈中else *(q++)=*p; //把'S'调到前部p++;}while(!StackEmpty(s)){pop(s,c);*(q++)=c; //把'H'接在后部}}//Train_arrange3.17int IsReverse()//判断输入的字符串中'&'前和'&'后部分是否为逆串,是则返回1,否则返回0{InitStack(s);while((e=getchar())!='&')push(s,e);while((e=getchar())!='@'){if(StackEmpty(s)) return 0;pop(s,c);if(e!=c) return 0;}if(!StackEmpty(s)) return 0;return 1;}//IsReverse3.18Status Bracket_Test(char *str)//判别表达式中小括号是否匹配{count=0;for(p=str;*p;p++){if(*p=='(') count++;else if(*p==')') count--;if (count<0) return ERROR;}if(count) return ERROR; //注意括号不匹配的两种情况return OK;}//Bracket_Test3.19Status AllBrackets_Test(char *str)//判别表达式中三种括号是否匹配{InitStack(s);for(p=str;*p;p++){if(*p=='('||*p=='['||*p=='{') push(s,*p);else if(*p==')'||*p==']'||*p=='}'){if(StackEmpty(s)) return ERROR;pop(s,c);if(*p==')'&&c!='(') return ERROR;if(*p==']'&&c!='[') return ERROR;if(*p=='}'&&c!='{') return ERROR; //必须与当前栈顶括号匹配}}//forif(!StackEmpty(s)) return ERROR;return OK;}//AllBrackets_Test3.20typedef struct {. int x;int y;} coordinate;void Repaint_Color(int g[m][n],int i,int j,int color)//把点(i,j)相邻区域的颜色置换为color{old=g[i][j];InitQueue(Q);EnQueue(Q,{I,j});while(!QueueEmpty(Q)){DeQueue(Q,a);x=a.x;y=a.y;if(x>1)if(g[x-1][y]==old){g[x-1][y]=color;EnQueue(Q,{x-1,y}); //修改左邻点的颜色}if(y>1)if(g[x][y-1]==old){g[x][y-1]=color;EnQueue(Q,{x,y-1}); //修改上邻点的颜色}if(x<m)if(g[x+1][y]==old){g[x+1][y]=color;EnQueue(Q,{x+1,y}); //修改右邻点的颜色}if(y<n)if(g[x][y+1]==old){g[x][y+1]=color;EnQueue(Q,{x,y+1}); //修改下邻点的颜色}}//while}//Repaint_Color分析:本算法采用了类似于图的广度优先遍历的思想,用两个队列保存相邻同色点的横坐标和纵坐标.递归形式的算法该怎么写呢?3.21void NiBoLan(char *str,char *new)//把中缀表达式str转换成逆波兰式new{p=str;q=new; //为方便起见,设str的两端都加上了优先级最低的特殊符号InitStack(s); //s为运算符栈while(*p){if(*p是字母)) *q++=*p; //直接输出else{c=gettop(s);if(*p优先级比c高) push(s,*p);else{while(gettop(s)优先级不比*p低){pop(s,c);*(q++)=c;}//whilepush(s,*p); //运算符在栈内遵循越往栈顶优先级越高的原则}//else}//elsep++;}//while}//NiBoLan //参见编译原理教材3.22int GetValue_NiBoLan(char *str)//对逆波兰式求值{p=str;InitStack(s); //s为操作数栈while(*p){if(*p是数) push(s,*p);else{pop(s,a);pop(s,b);r=compute(b,*p,a); //假设compute为执行双目运算的过程push(s,r);}//elsep++;}//whilepop(s,r);return r;}//GetValue_NiBoLan3.23Status NiBoLan_to_BoLan(char *str,stringtype &new)//把逆波兰表达式str转换为波兰式new{p=str;Initstack(s); //s的元素为stringtype类型while(*p){if(*p为字母) push(s,*p);else{if(StackEmpty(s)) return ERROR;pop(s,a);if(StackEmpty(s)) return ERROR;pop(s,b);c=link(link(*p,b),a);push(s,c);}//elsep++;}//whilepop(s,new);if(!StackEmpty(s)) return ERROR;return OK;}//NiBoLan_to_BoLan分析:基本思想见书后注释.本题中暂不考虑串的具体操作的实现,而将其看作一种抽象数据类型stringtype,对其可以进行连接操作:c=link(a,b).3.24Status g(int m,int n,int &s)//求递归函数g的值s{if(m==0&&n>=0) s=0;else if(m>0&&n>=0) s=n+g(m-1,2*n);else return ERROR;return OK;}//g3.25Status F_recursive(int n,int &s)//递归算法{if(n<0) return ERROR;if(n==0) s=n+1;else{F_recurve(n/2,r);s=n*r;}return OK;}//F_recursiveStatus F_nonrecursive(int n,int s)//非递归算法{if(n<0) return ERROR;if(n==0) s=n+1;else{InitStack(s); //s的元素类型为struct {int a;int b;}while(n!=0){a=n;b=n/2;push(s,{a,b});n=b;}//whiles=1;while(!StackEmpty(s)){pop(s,t);s*=t.a;}//while}return OK;}//F_nonrecursive3.26float Sqrt_recursive(float A,float p,float e)//求平方根的递归算法{if(abs(p^2-A)<=e) return p;else return sqrt_recurve(A,(p+A/p)/2,e);}//Sqrt_recurvefloat Sqrt_nonrecursive(float A,float p,float e)//求平方根的非递归算法{while(abs(p^2-A)>=e)p=(p+A/p)/2;return p;}//Sqrt_nonrecursive3.27这一题的所有算法以及栈的变化过程请参见《数据结构(pascal版)》,作者不再详细写出.3.28void InitCiQueue(CiQueue &Q)//初始化循环链表表示的队列Q{Q=(CiLNode*)malloc(sizeof(CiLNode));Q->next=Q;}//InitCiQueuevoid EnCiQueue(CiQueue &Q,int x)//把元素x插入循环链表表示的队列Q,Q指向队尾元素,Q->next指向头结点,Q->next->next指向队头元素{p=(CiLNode*)malloc(sizeof(CiLNode));p->data=x;p->next=Q->next; //直接把p加在Q的后面Q->next=p;Q=p; //修改尾指针}Status DeCiQueue(CiQueue &Q,int x)//从循环链表表示的队列Q头部删除元素x{if(Q==Q->next) return INFEASIBLE; //队列已空p=Q->next->next;x=p->data;Q->next->next=p->next;free(p);return OK;}//DeCiQueue3.29Status EnCyQueue(CyQueue &Q,int x)//带tag域的循环队列入队算法{if(Q.front==Q.rear&&Q.tag==1) //tag域的值为0表示"空",1表示"满"return OVERFLOW;Q.base[Q.rear]=x;Q.rear=(Q.rear+1)%MAXSIZE;if(Q.front==Q.rear) Q.tag=1; //队列满}//EnCyQueueStatus DeCyQueue(CyQueue &Q,int &x)//带tag域的循环队列出队算法{if(Q.front==Q.rear&&Q.tag==0) return INFEASIBLE;Q.front=(Q.front+1)%MAXSIZE;x=Q.base[Q.front];if(Q.front==Q.rear) Q.tag=1; //队列空return OK;}//DeCyQueue分析:当循环队列容量较小而队列中每个元素占的空间较多时,此种表示方法可以节约较多的存储空间,较有价值.3.30Status EnCyQueue(CyQueue &Q,int x)//带length域的循环队列入队算法{if(Q.length==MAXSIZE) return OVERFLOW;Q.rear=(Q.rear+1)%MAXSIZE;Q.base[Q.rear]=x;Q.length++;return OK;}//EnCyQueueStatus DeCyQueue(CyQueue &Q,int &x)//带length域的循环队列出队算法{if(Q.length==0) return INFEASIBLE;head=(Q.rear-Q.length+1)%MAXSIZE; //详见书后注释x=Q.base[head];Q.length--;}//DeCyQueue3.31int Palindrome_Test()//判别输入的字符串是否回文序列,是则返回1,否则返回0{InitStack(S);InitQueue(Q);while((c=getchar()!='@'){Push(S,c);EnQueue(Q,c); //同时使用栈和队列两种结构}while(!StackEmpty(S)){Pop(S,a);DeQueue(Q,b));if(a!=b) return ERROR;}return OK;}//Palindrome_Test3.32void GetFib_CyQueue(int k,int n)//求k阶斐波那契序列的前n+1项{InitCyQueue(Q); //其MAXSIZE设置为kfor(i=0;i<k-1;i++) Q.base[i]=0;Q.base[k-1]=1; //给前k项赋初值for(i=0;i<k;i++) printf("%d",Q.base[i]);for(i=k;i<=n;i++){m=i%k;sum=0;for(j=0;j<k;j++) sum+=Q.base[(m+j)%k];Q.base[m]=sum; //求第i项的值存入队列中并取代已无用的第一项printf("%d",sum);}}//GetFib_CyQueue3.33Status EnDQueue(DQueue &Q,int x)//输出受限的双端队列的入队操作{if((Q.rear+1)%MAXSIZE==Q.front) return OVERFLOW; //队列满avr=(Q.base[Q.rear-1]+Q.base[Q.front])/2;if(x>=avr) //根据x的值决定插入在队头还是队尾{Q.base[Q.rear]=x;Q.rear=(Q.rear+1)%MAXSIZE;} //插入在队尾else{Q.front=(Q.front-1)%MAXSIZE;Q.base[Q.front]=x;} //插入在队头return OK;}//EnDQueueStatus DeDQueue(DQueue &Q,int &x)//输出受限的双端队列的出队操作{if(Q.front==Q.rear) return INFEASIBLE; //队列空x=Q.base[Q.front];Q.front=(Q.front+1)%MAXSIZE;return OK;}//DeDQueue3.34void Train_Rearrange(char *train)//这里用字符串train表示火车,'P'表示硬座,'H'表示硬卧,'S'表示软卧,最终按PSH的顺序排列{r=train;InitDQueue(Q);while(*r){if(*r=='P'){printf("E");printf("D"); //实际上等于不入队列,直接输出P车厢 }else if(*r=='S'){printf("E");EnDQueue(Q,*r,0); //0表示把S车厢从头端入队列}else{printf("A");EnDQueue(Q,*r,1); //1表示把H车厢从尾端入队列}}//whilewhile(!DQueueEmpty(Q)){printf("D");DeDQueue(Q);}//while //从头端出队列的车厢必然是先S后H的顺序}//Train_Rearrange。
严蔚敏数据结构各章习题及答案
数据结构习题及解答第1章 概述【例1-1】分析以下程序段的时间复杂度。
for(i=0;i<n;i++) for(j=0;j<m;j++) A[i][j]=0;解：该程序段的时间复杂度为O (m*n )。
【例1-2】分析以下程序段的时间复杂度。
i=s=0; ① while(s<n) { i++; ② s+=i; ③ }解：语句①为赋值语句，其执行次数为1次，所以其时间复杂度为O (1)。
语句②和语句③构成while 循环语句的循环体，它们的执行次数由循环控制条件中s 与n 的值确定。
假定循环重复执行x 次后结束， 则语句②和语句③各重复执行了x 次。
其时间复杂度按线性累加规则为O (x )。
此时s 与n 满足关系式：s ≥n ，而s=1+2+3+…+x 。
所以有：1+2+3+…+x ≥n ，可以推出：x=nn 241212811+±-=+±-x 与n 之间满足x=f(n ），所以循环体的时间复杂度为O (n )，语句①与循环体由线性累加规则得到该程序段的时间复杂度为O (n ）。
【例1-3】分析以下程序段的时间复杂度。
i=1; ① while(i<=n) i=2*i; ②解：其中语句①的执行次数是1，设语句②的执行次数为f (n )，则有：n n f ≤)(2。
得：T（n）=O(n2 log)【例1-4】有如下递归函数fact(n)，分析其时间复杂度。
fact(int n){ if(n<=1)return(1);①elsereturn(n*fact(n-1));②}解：设fact（n）的运行时间函数是T(n)。
该函数中语句①的运行时间是O(1)，语句②的运行时间是T(n-1)+ O(1)，其中O(1)为常量运行时间。
由此可得fact（n）的时间复杂度为O(n)。
习题1一、单项选择题1.数据结构是指（1. A ）。
A.数据元素的组织形式B.数据类型C.数据存储结构D.数据定义2.数据在计算机存储器内表示时，物理地址与逻辑地址不相同的，称之为（2. C ）。
严蔚敏版数据结构课后习题答案-完整版
2n
2
，g
n
n n2
n5
解： (1)g(n) 快 (2)g(n) 快 (3)f(n) 快 (4) f(n) 快
1.15 试用数学归纳法证明：
n
(1)
i 2 n n 1 2n 1 / 6
i1
n0
n
(2)
xi
i0
xn 1 1 / x 1
x 1, n 0
n
(3)
2i 1 2n 1
i1
n1
n
(4)
2i 1 n 2
(2) 以函数的返回值判断正确与否常用于子程序的测试，便于实 现程序的局部控制。
(3) 用整型函数进行错误处理的优点是可以给出错误类型，便于 迅速确定错误。 1.7 在程序设计中，可采用下列三种方法实现输出和输入：
(1) 通过 scanf 和 printf 语句； (2) 通过函数的参数显式传递； (3) 通过全局变量隐式传递。 试讨论这三种方法的优缺点。
解：(1) 用 scanf 和 printf 直接进行输入输出的好处是形象、 直 观，但缺点是需要对其进行格式控制，较为烦琐，如果出现错误，则 会引起整个系统的崩溃。
(2) 通过函数的参数传递进行输入输出，便于实现信息的隐蔽， 减少出错的可能。
(3) 通过全局变量的隐式传递进行输入输出最为方便，只需修改 变量的值即可，但过多的全局变量使程序的维护较为困难。 1.8 设 n 为正整数。试确定下列各程序段中前置以记号 @的语句的频 度：
i1
n1
1.16 试写一算法，自大至小依次输出顺序读入的三个整数 X，Y 和 Z
的值
解：
int max3(int x,int y,int z)
{
严蔚敏数据结构课件chap3(2)
Status EnQueue (SqQueue &Q, QElemType e) { // 插入元素e为Q的新的队 尾元素 if ((Q.rear+1) % MAXQSIZE == Q.front) return ERROR; //队列满 Q.base[Q.rear] = e; Q.rear = (Q.rear+1) % MAXQSIZE; return OK; }
1 2 3 返址 n
5 7 5 8
a z
一、 抽象数据类型队列的定义 链队列---队列的链式表示 二、 链队列 队列的链式表示 和实现 循环队列---队列的顺序表 三、 循环队列 队列的顺序表 示和实现
队列的类型定义
ADT Queue { 数据对象： 数据对象： D＝{ai | ai∈ElemSet, i=1,2,...,n, n≥0} 数据关系： 数据关系： R1＝{ <a i-1,ai > | ai-1, ai ∈D, i=2,...,n} 约定其中a1 端为队列头 an 端为队列尾 队列头， 队列头 队列尾 基本操作： 基本操作： } ADT Queue
队列的基本操作： 队列的基本操作：
InitQueue(&Q) QueueEmpty(Q) GetHead(Q, &e) EnQueue(&Q, e) DestroyQueue(&Q) QueueLength(Q) ClearQueue(&Q) DeQueue(&Q, &e)
QueueTravers(Q, visit())
…
}// a
递归函数执行的过程可视为同一函数 同一函数 进行嵌套调用，例如：
递归工作栈： 递归工作栈：递归过程执行过程中占用的
数据结构严蔚敏C语言版第三章
2、返回栈顶元素 Status GetTop(SqStack S，SElemTtype &e) { if (S.top==S.base) return ERROR; e=*(S.top-1); return OK; }//end GetTop
switch(ch){ case ‘#’ : Pop(S,ch); //书上为c case ‘@’ : ClearStack(S); default : Push(S,ch); }//end switch
ch=getchar( ); }//end while 将从栈底到栈顶内的字符传送到用户数据区； ClearStack(s); if(ch!=eof) ch=gethar( ); } //end while DestroyStack(s); }//end LineEdit
InitStack(&S) 操作结果: 建立一个空栈S
DestroyStack(&S) 初始条件：栈S已存在 操作结果: 栈S被销毁
ClearStack(&S) 初始条件：栈S已存在 操作结果: 将S栈清空
StackEmpty(S) 初始条件：栈S已存在 操作结果：若栈S为空栈，返回true,否则返回false
v链栈
栈顶
top data next
栈底
…...
^
其操作与线性链表类似
3.2 栈的应用举例
3.2.1 3.2.2 3.2.3 3.2.5
Байду номын сангаас
数制转换 括号匹配的检验 行编辑程序 表达式求值
数据结构_(严蔚敏C语言版)_学 习、复习提纲
联接 比较 复制 子串查询
模式匹配 失败链接值
匹配算法 单字符链表串 多字符链表串
串变量的存储映像：
串名、串值对应关系表
第五章 数组和广义表 复习
数组
顺序存储方式 压缩存储方式 行优先顺序存放 列优先顺序存放 C语言数组：行优先 下标从[0]开始，公式变化 稀疏矩阵
应用 表达式 程序调用
广义表
运算
定义：n(≥0)个元素的有限序列 表头：Head(A)= a1
第八章 查找 复习
查找
概念： 查找的定义：确定一个已给的数据是否出现在某个数据表中。
MSL：最大查找长度：最多比较次数； ASL：平均查找长度：平均比较次数； 顺序表：记录的逻辑顺序与其在计算机存储器中存储的顺序一致
运算：联接
1、在双链表中，每个结点有两个指针域，包括一个指向前驱结点的指针 、一个指向后继结点的指针
2、线性表采用顺序存储，必须占用一片连续的存储单元 3、线性表采用链式存储，便于进行插入和删除操作 4、线性表采用顺序存储和链式存储优缺点比较。 5、简单算法
第三章 栈和队列 复习
栈
存储结构 栈的概念：在一端操作的线性表 运算算法 栈的特点：先进后出 LIFO 初始化 进栈push 出栈pop
二叉树 的遍历 已知先根、中根序列画树；已知后根、中根序列画树； 先根线索 中根线索 后根线索 线索 二叉树 线索树的画法
树、森林与二叉树的相互转换 树、森林的遍历
树、森林 二叉排序树
哈夫曼树 左中右ቤተ መጻሕፍቲ ባይዱ小中大
树的应用
哈夫曼树的画法 编码：左0右1
1、三个结点可以组成2种不同形态的树。 2、一个稀疏矩阵Am*n采用三元组形式表示，若完成了其的转置运算要 经过哪几步: 矩阵的行、列数值互换 、矩阵元素所在行列值互换、元素在矩阵中排 列的位置）重新排列 3、若二叉树中每一层结点的个数都达到了最大，则称为一棵满二叉 树。 4、树最适合用来表示现有元素之间具有分支层次关系的数据 5、哈夫曼树是带权路径长度最小的二叉树。 6、以下那些项为用十字链表表示的稀疏矩阵元素结点信息元素所在行 和列 、元素的值 、指向该元素所在行的下一个元素的指针 、指向 该元素所在列的下一个元素的指针。 7、一个广义表可以为其它广义表所共享。 8、广义表可以是一个多层次的结构。 9、压缩存储的三角矩阵和对称矩阵的存储空间相同。 10、广义表中的元素类型可以不相同。 11、两个稀疏矩阵的和仍为稀疏矩阵。 12、二叉树的先序遍历序列中，任意一个结点均处在其孩子结点的前 面。 13、对于一棵具有n个节点的树，该树中所有节点的度数之和为n-1。 14、树和森林的遍历中有中序遍历。 15、二叉树用链式存储时，空链域数多于非空链域数。
chap003 栈和队列-数据结构(C语言版)-严蔚敏-清华大学出版社
例三、行编辑程序问题
如何实现？
“每接受一个字符即存入存储器” ?
并不恰当！
在用户输入一行的过程中，允许 用户输入出差错，并在发现有误时 可以及时更正。 合理的作法是：
设立一个输入缓冲区，用以接受 用户输入的一行字符，然后逐行存 入用户数据区，并假设“#”为退格 符，“@”为退行符。
GetTop(S, &e) 初始条件：栈 S 已存在且非空。 操作结果：用 e 返回 S 的栈顶
元素。
a1 a2 … … an
ClearStack(&S) 初始条件：栈 S 已存在。 操作结果：将 S 清为空栈。
Push(&S, e) 初始条件：栈 S 已存在。 操作结果：插入元素 e 为新
的栈顶元素。
分析可能出现的不匹配的情况:
• 到来的右括弧并非是所“期待” • 的到；来的是“不速之客”；
• 直到结束，也没有到来所“期待” 的括弧。
算法的设计思想：
1）凡出现左括弧，则进栈；
2）凡出现右括弧，首先检查栈是否空 若栈空，则表明该“右括弧”多余， 否则和栈顶元素比较， 若相匹配，则“左括弧出栈” ， 否则表明不匹配。
} // conversion
例二、 括号匹配的检验 假设在表达式中 （［］（））或［（［ ］［ ］）］ 等为正确的格式， ［（ ］）或（［（ ））或 （（）］) 均为不正确的格式。
则 检验括号是否匹配的方法可用 “期待的急迫程度”这个概念来描述。
例如：考虑下列括号序列： [( [ ][ ] )] 1 2 34 5 6 7 8
switch (ch) {
数据结构严蔚敏(全部章节814张PPT)-(课件)
② 线性结构：结构中的数据元素之间存在一对一的 关系。
③ 树型结构：结构中的数据元素之间存在一对多的 关系。
④ 图状结构或网状结构：结构中的数据元素之间存 在多对多的关系。
图1-3 四类基本结构图
1.1.3 数据结构的形式定义
数据结构的形式定义是一个二元组： Data-Structure=(D，S)
计算机求解问题的一般步骤
编写解决实际问题的程序的一般过程：
– 如何用数据形式描述问题?—即由问题抽象出一个 适当的数学模型; – 问题所涉及的数据量大小及数据之间的关系; – 如何在计算机中存储数据及体现数据之间的关系? – 处理问题时需要对数据作何种运算? – 所编写的程序的性能是否良好? 上面所列举的问题基本上由数据结构这门课程来回答。
其中：D是数据元素的有限集，S是D上关系的有限集。 例2：设数据逻辑结构B=（K，R）
K={k1, k2, …, k9} R={ <k1, k3>，<k1, k8>，<k2, k3>，<k2, k4>，<k2, k5>，<k3, k9>， <k5, k6>，<k8, k9>，<k9, k7>，<k4, k7>，<k4, k6> } 画出这逻辑结构的图示，并确定那些是起点，那些是终点
<基本操作名>(<参数表>) 初始条件： <初始条件描述> 操作结果： <操作结果描述>
– 初始条件：描述操作执行之前数据结构和参数应 满足的条件;若不满足，则操作失败，返回相应的出 错信息。
《数据结构（C语言版第2版）》（严蔚敏著）第三章练习题答案
《数据结构（C语言版第2版）》（严蔚敏著）第三章练习题答案《数据结构（C语言版第2版）》（严蔚敏著）第三章练习题答案第3章栈和队列1．选择题（1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（）种情况。
A．5，4，3，2，1 B．2，1，5，4，3 C．4，3，1，2，5 D．2，3，5，4，1答案：C解释：栈是后进先出的线性表，不难发现C选项中元素1比元素2先出栈，违背了栈的后进先出原则，所以不可能出现C选项所示的情况。
（2）若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为（）。
A．i B．n-i C．n-i+1 D．不确定答案：C解释：栈是后进先出的线性表，一个栈的入栈序列是1，2，3，…，n，而输出序列的第一个元素为n，说明1，2，3，…，n一次性全部进栈，再进行输出，所以p1=n，p2=n-1，…，pi=n-i+1。
（3）数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素个数的公式为（）。
A．r-f B．(n+f-r)%n C．n+r-f D．（n+r-f)%n答案：D解释：对于非循环队列，尾指针和头指针的差值便是队列的长度，而对于循环队列，差值可能为负数，所以需要将差值加上MAXSIZE（本题为n），然后与MAXSIZE（本题为n）求余，即（n+r-f)%n。
（4）链式栈结点为：(data,link)，top指向栈顶.若想摘除栈顶结点，并将删除结点的值保存到x中,则应执行操作（）。
A．x=top->data;top=top->link；B．top=top->link;x=top->link；C．x=top;top=top->link；D．x=top->link；答案：A解释：x=top->data将结点的值保存到x中，top=top->link栈顶指针指向栈顶下一结点，即摘除栈顶结点。
数据结构(C语言版)严蔚敏清华大学出版社课件第三章 栈和队列
顺序栈S an an-1 ……
栈顶top
ai …… a1 a0
栈底base
问：顺序表和顺序栈的操作有何区别？ 以线性表 S= (a0 , a1 , …. , an-2 , an-1)为例
顺序表S
高地址
顺序栈S
表尾
高地址
栈顶top 栈顶top
an-1 …… S[i] ai ……
低地址
an an-1 …… ai …… a1 a0
(5)取栈顶数据元素
int StackTop(SeqStack S, DataType *d) /*取顺序堆栈S的当前栈顶数据元素值到参数d ，成功 则返回1，否则返回0*/ { if(S.top <= 0) { printf("堆栈已空! \n"); return 0; } else { *d = S.stack[S.top - 1]; return 1; } }
6、栈“上溢” 在栈满时还进行入栈运算，必定会产生空间的溢 出 7、栈“下溢” 当栈空时仍进行出栈运算，必定会产生空间的溢 出。 上溢是一种出错状态，应该设法避免之；下溢则 可能是正常现象，因为栈在程序中使用时，其初 态或终态都是空栈，所以下溢常常用来作为程序 控制转移的条件。
栈 是仅在表尾进行插入、删除操作的线性表。 表尾(即 an 端)称为栈顶 /top ; 表头(即 a1 端)称为栈底/base
a1 a2
……
an-1 an
4 栈的顺序表示和实现
栈有两种存储表示方法：顺序栈、链栈。 顺序栈：即栈的顺序存储结构是利用一组地址连 续的存储单元依次存放自栈底到栈顶的数据元 素，同时附设指针top指示栈顶元素在顺序栈中 的存储位臵。
习惯做法是以top＝0表示空栈，由于c语言中数 组的下标约定从0开始，则当以c作描述语言时， 如此设定会带来很大不便，另一方面，由于栈 在使用过程中所需最大空间的大小很难估计， 因此，在初始化设空栈时不应限定栈的最大容 量。
清华大学严蔚敏数据结构习题集(C版)答案
清华大学严蔚敏数据结构习题集（C版）答案清华大学严蔚敏数据结构习题集（C版）答案第一章绪论1.16void print_descending(int x,int y,int z)//按从大到小顺序输出三个数{scanf("%d,%d,%d",&x,&y,&z);if(x<y) x<->y; //<->为表示交换的双目运算符,以下同if(y<z) y<->z;if(x<y) x<->y; //冒泡排序printf("%d %d %d",x,y,z);}//print_descending1.17Status fib(int k,int m,int &f)//求k阶斐波那契序列的第m项的值f{int tempd;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp=0;temp[k-1]=1; //初始化for(i=k;i<=m;i++) //求出序列第k至第m个元素的值{sum=0;for(j=i-k;j<i;j++) sum+=temp[j];temp=sum;}f=temp[m];}return OK;}//fib分析:通过保存已经计算出来的结果,此方法的时间复杂度仅为O(m^2).如果采用递归编程(大多数人都会首先想到递归方法),则时间复杂度将高达O(k^m).1.18typedef struct{char *sport;enum{male,female} gender; char schoolname; //校名为'A','B','C','D'或'E'char *result;int score;} resulttype;typedef struct{int malescore;int femalescore;int totalscore;} scoretype;void summary(resulttype result[ ])//求各校的男女总分和团体总分,假设结果已经储存在result[ ]数组中{scoretype score;i=0;while(result.sport!=NULL){switch(result.schoolname){case 'A':score[ 0 ].totalscore+=result.score;if(result.gender==0)score[ 0 ].malescore+=result.score;elsescore[ 0 ].femalescore+=result.score;break;case 'B':score.totalscore+=result.score;if(result.gender==0)score.malescore+=result.score;else score.femalescore+=result.score;break;………………}i++；}for(i=0;i<5;i++){printf("School %d:\n",i);printf("Total score ofmale:%d\n",score.malescore);printf("Total score offemale:%d\n",score.femalescore);printf("Total score ofall:%d\n\n",score.totalscore);}}//summary1.19Status algo119(int a[ARRSIZE])//求i!*2^i序列的值且不超过maxint{last=1;for(i=1;i<=ARRSIZE;i++){a[i-1]=last*2*i;if((a[i-1]/last)!=(2*i)) reurn OVERFLOW;last=a[i-1];return OK;}}//algo119分析:当某一项的结果超过了maxint时,它除以前面一项的商会发生异常.1.20void polyvalue(){float ad;float *p=a;printf("Input number of terms:");scanf("%d",&n);printf("Input the %d coefficients from a0 toa%d:\n",n,n);for(i=0;i<=n;i++) scanf("%f",p++);printf("Input value of x:");scanf("%f",&x);p=a;xp=1;sum=0; //xp用于存放x的i次方for(i=0;i<=n;i++){sum+=xp*(*p++);xp*=x;}printf("Value is:%f",sum);}//polyvalue第二章线性表2.10Status DeleteK(SqList &a,int i,int k)//删除线性表a中第i个元素起的k个元素{if(i<1||k<0||i+k-1>a.length) returnINFEASIBLE;for(count=1;i+count-1<=a.length-k;c ount++) //注意循环结束的条件a.elem[i+count-1]=a.elem[i+count+k-1];a.length-=k;return OK;}//DeleteK2.11Status Insert_SqList(SqList &va,int x)//把x插入递增有序表va中{if(va.length+1>va.listsize) returnERROR;va.length++;for(i=va.length-1;va.elem>x&&i>=0;i--)va.elem[i+1]=va.elem;va.elem[i+1]=x;return OK;}//Insert_SqList2.12int ListComp(SqList A,SqList B)//比较字符表A和B,并用返回值表示结果,值为正,表示A>B;值为负,表示A<B;值为零,表示A=B{for(i=1;A.elem||B.elem;i++)if(A.elem!=B.elem) returnA.elem-B.elem;return 0;}//ListComp2.13LNode* Locate(LinkList L,int x)//链表上的元素查找,返回指针{for(p=l->next;p&&p->data!=x;p=p->next);return p;}//Locate2.14int Length(LinkList L)//求链表的长度{for(k=0,p=L;p->next;p=p->next,k++);return k;}//Length2.15void ListConcat(LinkList ha,LinkList hb,LinkList &hc)//把链表hb接在ha后面形成链表hc{hc=ha;p=ha;while(p->next) p=p->next;p->next=hb;}//ListConcat2.16见书后答案.2.17Status Insert(LinkList &L,int i,int b)//在无头结点链表L的第i个元素之前插入元素b{p=L;q=(LinkList*)malloc(sizeof(LNode));q.data=b;if(i==1){q.next=p;L=q; //插入在链表头部}else{while(--i>1) p=p->next;q->next=p->next;p->next=q; //插入在第i个元素的位置}}//Insert2.18Status Delete(LinkList &L,int i)//在无头结点链表L中删除第i个元素{if(i==1) L=L->next; //删除第一个元素else{p=L;while(--i>1) p=p->next;p->next=p->next->next; //删除第i个元素}}//Delete2.19Status Delete_Between(Linklist &L,int mink,int maxk)//删除元素递增排列的链表L中值大于mink且小于maxk的所有元素{p=L;while(p->next->data<=mink) p=p->next;//p是最后一个不大于mink的元素if(p->next) //如果还有比mink更大的元素{q=p->next;while(q->data<maxk) q=q->next; //q 是第一个不小于maxk的元素p->next=q;}}//Delete_Between2.20Status Delete_Equal(Linklist &L)//删除元素递增排列的链表L中所有值相同的元素{p=L->next;q=p->next; //p,q指向相邻两元素while(p->next){if(p->data!=q->data){p=p->next;q=p->next; //当相邻两元素不相等时,p,q都向后推一步}else{while(q->data==p->data){free(q);q=q->next;}p->next=q;p=q;q=p->next; //当相邻元素相等时删除多余元素}//else}//while}//Delete_Equal2.21void reverse(SqList &A)//顺序表的就地逆置{for(i=1,j=A.length;i<j;i++,j--)A.elem<->A.elem[j];}//reverse2.22void LinkList_reverse(Linklist &L)//链表的就地逆置;为简化算法,假设表长大于2{p=L->next;q=p->next;s=q->next;p->next=NULL;while(s->next){q->next=p;p=q;q=s;s=s->next; //把L的元素逐个插入新表表头}q->next=p;s->next=q;L->next=s;}//LinkList_reverse分析:本算法的思想是,逐个地把L的当前元素q插入新的链表头部,p为新表表头.2.23void merge1(LinkList &A,LinkList &B,LinkList &C)//把链表A和B合并为C,A 和B的元素间隔排列,且使用原存储空间{p=A->next;q=B->next;C=A;while(p&&q){s=p->next;p->next=q; //将B的元素插入if(s){t=q->next;q->next=s; //如A非空,将A的元素插入}p=s;q=t;}//while}//merge12.24void reverse_merge(LinkList&A,LinkList &B,LinkList &C)//把元素递增排列的链表A和B合并为C,且C中元素递减排列,使用原空间{pa=A->next;pb=B->next;pre=NULL; //pa 和pb分别指向A,B的当前元素while(pa||pb){if(pa->data<pb->data||!pb){pc=pa;q=pa->next;pa->next=pre;p a=q; //将A的元素插入新表}else{pc=pb;q=pb->next;pb->next=pre;p b=q; //将B的元素插入新表}pre=pc;}C=A;A->next=pc; //构造新表头}//reverse_merge分析:本算法的思想是,按从小到大的顺序依次把A和B的元素插入新表的头部pc处,最后处理A或B的剩余元素.2.25void SqList_Intersect(SqList A,SqList B,SqList &C)//求元素递增排列的线性表A 和B的元素的交集并存入C中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;if(A.elem>B.elem[j]) j++;if(A.elem==B.elem[j]){C.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素,i++;j++; //就添加到C中}}//while}//SqList_Intersect2.26void LinkList_Intersect(LinkList A,LinkList B,LinkList &C)//在链表结构上重做上题{p=A->next;q=B->next;pc=(LNode*)malloc(sizeof(LNode));while(p&&q){if(p->data<q->data) p=p->next;else if(p->data>q->data) q=q->next;else{s=(LNode*)malloc(sizeof(LNode));s->data=p->data;pc->next=s;pc=s;p=p->next;q=q->next;}}//whileC=pc;}//LinkList_Intersect2.27void SqList_Intersect_True(SqList&A,SqList B)//求元素递增排列的线性表A 和B的元素的交集并存回A中{i=1;j=1;k=0;while(A.elem&&B.elem[j]){if(A.elem<B.elem[j]) i++;else if(A.elem>B.elem[j]) j++;else if(A.elem!=A.elem[k]){A.elem[++k]=A.elem; //当发现了一个在A,B中都存在的元素i++;j++; //且C中没有,就添加到C中}}//whilewhile(A.elem[k]) A.elem[k++]=0;}//SqList_Intersect_True2.28void LinkList_Intersect_True(LinkList &A,LinkList B)//在链表结构上重做上题{p=A->next;q=B->next;pc=A;while(p&&q){if(p->data<q->data) p=p->next; else if(p->data>q->data) q=q->next;else if(p->data!=pc->data){pc=pc->next;pc->data=p->data;p=p->next;q=q->next;}}//while}//LinkList_Intersect_True2.29void SqList_Intersect_Delete(SqList&A,SqList B,SqList C){i=0;j=0;k=0;m=0; //i指示A中元素原来的位置,m为移动后的位置while(i<A.length&&j<B.length&&k<C.length){if(B.elem[j]<C.elem[k]) j++;else if(B.elem[j]>C.elem[k]) k++;else{same=B.elem[j];//找到了相同元素same while(B.elem[j]==same) j++;while(C.elem[k]==same)k++; //j,k后移到新的元素while(i<A.length&&A.elem<same)A.elem[m++]=A.elem[i++];//需保留的元素移动到新位置while(i<A.length&&A.elem==same) i++; //跳过相同的元素}}//whilewhile(i<A.length)A.elem[m++]=A.elem[i++]; //A的剩余元素重新存储。
严蔚敏版数据结构第3章
p->prior=s;
双向链表的删除
P
a
b
c
p->prior->next=p->next; p->next->prior=p->prior;
一元多项式
coef
系数域
exp
指数域
next
– 一元多项式相加
A( x) 7 3x 9 x 8 5 x17 B( x) 8 x 22x 7 9 x 8 7 C( x) A( x) B( x) 7 11x 22x 5x17
思考题： LinkList mynote(LinkList L)
{ //L是不带结点的单链表的头指针
if(L&&L->next){ q=L; L=L->next; p=L; s1: while(p->next) p=p->next; s2: p->next=q; q->next=null;}
return L;}
++temp;
} // 将从栈底到栈顶的栈内字符传送至调用过程的数据区； ClearStack(S); printf("\n"); if (ch != EOF) { printf("请输入一行(#:退格；@:清行):\n"); ch = getchar(); } } // 重置S为空栈
DestroyStack(S);
4. 判定一个顺序栈ST（最多元素为m0）为空的条件 是____。 B
A. top !=0 B. top= =0 C. top !=m0 D. top= =m0-1
数据结构(严蔚敏)chapter3 simple sorting
Chapter 3 Simple Sorting
2021/8/5
1
Simple Sorting
一旦建立了一个重要数据库后，就可能根据某些需 要对数据进行不同方式的排序。
e.g.
姓名按照字母序 学生按照年级/学号/成绩 顾客按照邮政编码
2. Swap two items or copy one item.
2021/8/5
6
② Bubble Sort
冒泡排序算法运行起来 非常慢，但原理最简单
遵循以下规则:
1. Compare two players.
2. If the one on the left is taller, swap them.
2021/8/5
21
A brief description
假定：队列排好了一半(局部 有序)
✓ 在队伍中间有一个作为标记 的队员，其左边所有元素按 照顺序排列，右边元素等待 插入到合适位置
✓ 标记队员出列
✓ 依次比较标记队员与有序队 列中队员身高，如比标记队 员高，则移动至空位，直至 没有比当前标记队员高的。
① How Would You Do It? ② Bubble Sort ③ Selection Sort ④ Insertion Sort ⑤ Sorting Objects ⑥ Comparing the Simple Sorts
2021/8/5
4
① How Would You Do
It?
Imagine that your kids-league baseball team is lined up on the field. The regulation nine players, plus an extra, have shown up for practice. You want to arrange the players in order of increasing height (with the shortest player on the left), for the team picture.
《数据结构(C语言版 第2版)》(严蔚敏 著)第三章练习题答案
《数据结构（C语言版第2版）》（严蔚敏著）第三章练习题答案第3章栈和队列1．选择题（1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（）种情况。
A．5，4，3，2，1 B．2，1，5，4，3 C．4，3，1，2，5 D．2，3，5，4，1答案：C解释：栈是后进先出的线性表，不难发现C选项中元素1比元素2先出栈，违背了栈的后进先出原则，所以不可能出现C选项所示的情况。
（2）若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为（）。
A．i B．n-i C．n-i+1 D．不确定答案：C解释：栈是后进先出的线性表，一个栈的入栈序列是1，2，3，…，n，而输出序列的第一个元素为n，说明1，2，3，…，n一次性全部进栈，再进行输出，所以p1=n，p2=n-1，…，pi=n-i+1。
（3）数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素个数的公式为（）。
A．r-f B．(n+f-r)%n C．n+r-f D．（n+r-f)%n答案：D解释：对于非循环队列，尾指针和头指针的差值便是队列的长度，而对于循环队列，差值可能为负数，所以需要将差值加上MAXSIZE（本题为n），然后与MAXSIZE（本题为n）求余，即（n+r-f)%n。
（4）链式栈结点为：(data,link)，top指向栈顶.若想摘除栈顶结点，并将删除结点的值保存到x中,则应执行操作（）。
A．x=top->data;top=top->link；B．top=top->link;x=top->link；C．x=top;top=top->link；D．x=top->link；答案：A解释：x=top->data将结点的值保存到x中，top=top->link栈顶指针指向栈顶下一结点，即摘除栈顶结点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
顺序栈的基本运算:
• 判栈空 • int StackEmpty (SeqStack *S) { • if( S->top == S->base ) return 1 //空则返回1 else return 0; //否则返回0 • } • 判栈满 • int StackFull (SeqStack *S) { • if( S->top- S->base >= S-> StackSize ) return 1 //判栈满,满则返回1 • else return 0; //否则返回0 • } 9
―进” ＝压入=PUSH（x) ―出” ＝弹出=POP ( y )
4
教材P44对栈有更详细定义：
栈 是仅在表尾进行插入、删除操作的线性表。 表尾(即 an 端)称为栈顶 top ; 表头(即 a1 端)称为栈底base 例如： 栈 s= (a1 , a2 , a3
, ……….,an-1 ,
an ) an 称为 栈顶元素
顺序栈中的PUSH函数 status Push(ElemType x) { if(top>M){上溢} else v[top++]=x; }
12
• 入栈 • int Push (SeqStack *S, StackData x) { • //插入元素x为新的栈顶元素 • if ( StackFull (S) ){ • S->base =( StackData *)malloc(S->base , • (S->stacksize+ STACKINCREMENT) * sizeof(StackData)); • if(! S->base)exit(overflow); • S->top= S->base + S->stacksize; • S->stacksize+= STACKINCREMENT; //追加存储空间 • } • *(S->top)=x; • （S->top）++; • Return ok • } 13
3. 存储结构
4. 运算规则
5. 实现方式
基本操作有入栈、出栈、读栈顶元素值、建 栈、或判断栈满、栈空等。
3
3.1 栈
问：堆栈是什么？它与一般线性表有什么不同？
答：堆栈是一种特殊的线性表，它只能在表的一端 （即栈顶）进行插入和删除运算。 与一般线性表的区别：仅在于运算规则不同。
一般线性表 逻辑结构：一对一 存储结构：顺序表、链表 运算规则：随机存取 堆栈 逻辑结构：一对一 存储结构：顺序栈、链栈 运算规则：后进先出(LIFO)
出栈操作——例如从栈中取出‘B‘ （注意要遵循“后进先出” 原则）
高地址M
top D C B A
低地址L
D top C B A
D C B A
D top C B A
top
核心语句： Pop ( ); Pop ( ); Printf( Pop () );
顺序栈中的POP函数 status Pop( ) { if(top=L) { 下溢 } else { y=v[--top]; return(y);} }
top base top base
top
a a 进栈
base
b a
空栈
b 进栈
6
顺序栈示意图
data
s
top
99 . . . 3 2 1 0
(栈顶)
a3 a2 a1
(栈底)
顺序栈的类型表示:
• #define STACK_INIT_SIZE 100； • #define STACKINCREMENT 10； • typedef char StackData; • typedef struct { //顺序栈定义 • StackData *base; //栈底指针 • StackData *top; //栈顶指针 • int stacksize；//当前已分配的存储空间 • } SeqStack；
Return ok;
}
10
表和栈的操作区别——对线性表 s= (a1 , a2 顺序表V[n]高地址,ຫໍສະໝຸດ …. , an-1 ,an )
表尾 an ……
高地址
顺序栈S an+1 an ……
ai …… a2 a1
栈顶top
v[i]
ai ……
低地址
a2 a1
表头
低地址
栈底base
写入：v[i]= ai 读出： x= v[i]
数据结构课程的内容
1
第三章 栈和队列
3.1 栈（Stack） 3.2 队列（Queue）
1. 定义 2. 逻辑结构 3. 存储结构 4. 运算规则 5. 实现方式 1. 定义 2. 逻辑结构 3. 存储结构 4. 运算规则 5. 实现方式
2
3.1 栈
1. 定义
2. 逻辑结构
限定只能在表的一端进行插入和删除运算的 线性表（只能在栈顶操作） 与同线性表相同，仍为一对一关系。 用顺序栈或链栈存储均可，但以顺序栈更常见 只能在栈顶运算，且访问结点时依照后进先出 （LIFO）或先进后出（FILO）的原则。 关键是编写入栈和出栈函数，具体实现依顺 序栈或链栈的不同而不同。
初始化
void InitStack ( SeqStack *S) { //置空栈
S->base =( StackData *)malloc(STACK_INIT_SIZE * sizeof(StackData)); if (!S->base) exit(OVERFLOW); S->top = S->base ; S->stacksize= STACK_INIT_SIZE ;
压入：PUSH (an+1) 弹出： POP (x) 前提：一定要预设栈顶指针top！
11
入栈操作——例如用堆栈存放（A，B，C，D） （注意要遵循“后进先出” 原则）
高地址M
低地址L
top A
B top A
top C B A
top
D C B A
top
核心语句： top=L; Push (A); Push (B); Push (C); Push (D);
a1 称为 栈底元素
插入元素到栈顶（即表尾）的操作，称为入栈。 从栈顶（即表尾）删除最后一个元素的操作，称为出栈。
强调：插入和删除都只能在表的一端（栈顶）进行！
5
栈的表示和实现
• 顺序栈：栈的顺序存储结构，利用一组地 址连续的存储单元依次存放自栈底到栈顶 的数据元素，指针top指向栈顶元素在顺 序栈中的下一个位置， • base为栈底指针，指向栈底的位置。