数据结构-栈代码

合集下载

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现:```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满,无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

大学数据结构课件--第3章 栈和队列

大学数据结构课件--第3章 栈和队列
top top 栈空 F E D C B A
栈满 top-base=stacksize
top
F
E
D C B
top top top top top top base
入栈PUSH(s,x):s[top++]=x; top 出栈 POP(s,x):x=s[--top]; top
base
4
A
3.1 栈
例1:一个栈的输入序列为1,2,3,若在入栈的过程中 允许出栈,则可能得到的出栈序列是什么? 答: 可以通过穷举所有可能性来求解:
3.2 栈的应用举例
二、表达式求值
“算符优先法”
一个表达式由操作数、运算符和界限符组成。 # 例如:3*(7-2*3) (1)要正确求值,首先了解算术四则运算的规则 a.从左算到右 b.先乘除后加减 c.先括号内,后括号外 所以,3*(7-2*3)=3*(7-6)=3*1=3
9
3.2 栈的应用举例
InitStack(S); while (!QueueEmpty(Q))
{DeQueue(Q,d);push(S,d);}
while (!StackEmpty(S)) {pop(S,d);EnQueue(Q,d);} }
第3章 栈和队列
教学要求:
1、掌握栈和队列的定义、特性,并能正确应用它们解决实 际问题;
用一组地址连续的存储单元依次存放从队头到队尾的元素, 设指针front和rear分别指示队头元素和队尾元素的位置。
Q.rear 5 4 Q.rear 3 2 3 2 5 4 Q.rear 3 3 5 4 5 4
F E D C
C B A
Q.front
2 1 0
C B
Q.front 2 1 0

数据结构c语言实现

数据结构c语言实现

数据结构c语言实现数据结构是计算机科学中重要的一个领域,它研究不同的数据组织方式,以及在这些数据上进行各种操作的算法。

常见的数据结构包括数组、栈、队列、链表、树、图等。

在C语言中,数据结构是通过使用结构体来实现的。

结构体是由一组数据成员组合而成的自定义数据类型,可以包含不同数据类型的数据成员。

以下是如何在C语言中实现不同的数据结构。

数组数组是数据结构中最基本的数据结构之一。

C语言中的数组定义方式如下:```int array[5];```这个代码定义了一个名为array的数组,其中有5个元素,每个元素的类型是整数。

要访问数组中的元素,可以通过下标访问:这个代码设置了数组中第一个元素的值为1。

栈栈是一种后进先出(LIFO)的数据结构。

使用C语言中的数组可以实现栈。

以下是一个简单的栈实现:```#define MAXSIZE 100int stack[MAXSIZE];int top = -1;void push(int data){if(top<MAXSIZE-1){ //判断栈是否满了stack[++top] = data; //插入数据}}int isEmpty(){return top==-1; //栈是否为空}队列链表链表是一个由节点组成的数据结构,每个节点包含一个数据成员和一个指向下一个节点的指针。

在C语言中,链表可以使用结构体和指针来实现。

以下是一个单向链表的实现:```struct node{int data;struct node *next;};struct node *head = NULL;void insert(int data){struct node *new_node = (struct node*) malloc(sizeof(struct node)); //分配内存new_node->data = data; //初始化数据new_node->next = head; //新节点指向当前头节点head = new_node; //更新头节点}void delete(int data){struct node *current_node = head; //从头节点开始查找struct node *previous_node = NULL;while(current_node!=NULL&&current_node->data!=data){ //查找节点previous_node = current_node;current_node = current_node->next;}if(current_node!=NULL){ //找到了节点if(previous_node!=NULL){ //非头节点previous_node->next = current_node->next; }else{ //头节点head = current_node->next;}free(current_node); //释放内存}}树。

《数据结构(C语言)》第3章 栈和队列

《数据结构(C语言)》第3章 栈和队列
Data structures

❖ 栈的顺序存储与操作 ❖ 1.顺序栈的定义
(1) 栈的静态分配顺序存储结构描述 ② top为整数且指向栈顶元素 当top为整数且指向栈顶元素时,栈空、入栈、栈满 及出栈的情况如图3.2所示。初始化条件为 S.top=-1。
(a) 栈空S.top==-1 (b) 元素入栈S.stack[++S.top]=e (c) 栈满S.top>=StackSize-1 (d) 元素出栈e=S.stack[S.top--]
/*栈顶指针,可以指向栈顶
元素的下一个位置或者指向栈顶元素*/
int StackSize; /*当前分配的栈可使用的以 元素为单位的最大存储容量*/
}SqStack;
/*顺序栈*/
Data structures

❖ 栈的顺序存储与操作 ❖ 1.顺序栈的定义
(2) 栈的动态分配顺序存储结构描述 ① top为指针且指向栈顶元素的下一个位置 当top为指针且指向栈顶元素的下一个位置时,栈空 、入栈、栈满及出栈的情况如图3.3所示。初始化条 件为S.top=S.base。
…,n-1,n≥0} 数据关系:R={< ai-1,ai>| ai-1,ai∈D,i=1,2
,…,n-1 } 约定an-1端为栈顶,a0端为栈底 基本操作:
(1) 初始化操作:InitStack(&S) 需要条件:栈S没有被创建过 操作结果:构建一个空的栈S (2) 销毁栈:DestroyStack(&S) 需要条件:栈S已经被创建 操作结果:清空栈S的所有值,释放栈S占用的内存空间
return 1;
}
Data structures

数据结构基础栈和队列

数据结构基础栈和队列
②X=S[TOP],(退栈后的元素赋给X); ③TOP--,结束(栈指针减1,指向栈顶)。
栈的应用 十进制数N和其它d进制数的转换是实现计算的基本问题,
解决方法很多,下面给出一种算法原理: N=(N / d)×d+N % d (其中 / 为整除运算,%为求余运算)。
例如:(1348)10=(2504)8运算过程如下:
default:x=0; while (s[i]!=' ') x=x*10+s[i++]-'0'; stack[++top]=x;
break;
}
i++;
}
//while
return stack[top];
}
main() {
printf("input a string(@_over):"); gets(s); printf("result=%d",comp(s)); return 0; }
cout<<"Please enter a number(N) base 10:"; cin>>n; cout<<"please enter a number(d):"; cin>>d; do{
a[++i]=n%d; n=n/d; }while(n!=0); for (j=i;j>=1;j--)cout<<a[j]; return 0; }
集合
• 数据元素的物理结构有两种:顺序存储结构和链 式存储结构
• 顺序存储结构:用数据元素在存储器中的相对位 置来表示数据元素之间的逻辑关系。

数据结构(一)——线性表、栈和队列

数据结构(一)——线性表、栈和队列

数据结构(⼀)——线性表、栈和队列数据结构是编程的起点,理解数据结构可以从三⽅⾯⼊⼿:1. 逻辑结构。

逻辑结构是指数据元素之间的逻辑关系,可分为线性结构和⾮线性结构,线性表是典型的线性结构,⾮线性结构包括集合、树和图。

2. 存储结构。

存储结构是指数据在计算机中的物理表⽰,可分为顺序存储、链式存储、索引存储和散列存储。

数组是典型的顺序存储结构;链表采⽤链式存储;索引存储的优点是检索速度快,但需要增加附加的索引表,会占⽤较多的存储空间;散列存储使得检索、增加和删除结点的操作都很快,缺点是解决散列冲突会增加时间和空间开销。

3. 数据运算。

施加在数据上的运算包括运算的定义和实现。

运算的定义是针对逻辑结构的,指出运算的功能;运算的实现是针对存储结构的,指出运算的具体操作步骤。

因此,本章将以逻辑结构(线性表、树、散列、优先队列和图)为纵轴,以存储结构和运算为横轴,分析常见数据结构的定义和实现。

在Java中谈到数据结构时,⾸先想到的便是下⾯这张Java集合框架图:从图中可以看出,Java集合类⼤致可分为List、Set、Queue和Map四种体系,其中:List代表有序、重复的集合;Set代表⽆序、不可重复的集合;Queue代表⼀种队列集合实现;Map代表具有映射关系的集合。

在实现上,List、Set和Queue均继承⾃Collection,因此,Java集合框架主要由Collection和Map两个根接⼝及其⼦接⼝、实现类组成。

本⽂将重点探讨线性表的定义和实现,⾸先梳理Collection接⼝及其⼦接⼝的关系,其次从存储结构(顺序表和链表)维度分析线性表的实现,最后通过线性表结构导出栈、队列的模型与实现原理。

主要内容如下:1. Iterator、Collection及List接⼝2. ArrayList / LinkedList实现原理3. Stack / Queue模型与实现⼀、Iterator、Collection及List接⼝Collection接⼝是List、Set和Queue的根接⼝,抽象了集合类所能提供的公共⽅法,包含size()、isEmpty()、add(E e)、remove(Object o)、contains(Object o)等,iterator()返回集合类迭代器。

【数据结构】栈操作

【数据结构】栈操作

【数据结构】栈操作//111111111111111111111111111第一部分1111111111111111111111111#include<stdio.h>#define STACK_INIT_SIZE 5#define STACKINCREMENT 1#define ERROR 0#define OK 1;//原来我们定义一个int类型的ElemType,//这次我们定义一个int类型的SElemType,typedef int SElemType;typedef int Status;typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;//注意,这里面没有加*LinkList,如果你想加,也可以。

//111111111111111111111111111第一部分结束1111111111111111111111111//222222222222222222222222222第二部分2222222222222222222222222222 //链表的操作//初始化int InitStack(SqStack *S){S->base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S->base){printf("!\n");exit(ERROR);}S->top = S->base;S->stacksize=STACK_INIT_SIZE;printf("栈初始化完毕!,现在栈的空间是%d个\n",STACK_INIT_SIZE);return OK;}// 入栈(插入元素)Status Push(SqStack *S,SElemType e){//如果栈已满,需要申请空间if(S->top - S->base >= S->stacksize){//这个地方区分realloc和malloc的区别S->base=(SElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));if(!S->base){printf("存储分配失败!\n");exit(ERROR);}S->top=S->base+S->stacksize;S->stacksize=S->stacksize+STACKINCREMENT;}//入栈是先把元素赋给栈顶指针*S->top=e;//然后让栈顶指针加1S->top = S->top + 1;return OK;}// 出栈(删除栈顶元素)//元素一定是指针,SElemType *e,因为你要将元素返回来了Status Pop(SqStack *S,SElemType *e){if(S->base == S->top){printf("栈空!\n");return ERROR;}//出栈是先把栈顶指针减去1S->top = S->top - 1;//再把元素赋给指针变量e所指向的空间e=*S->top;printf("出栈成功!\n");return OK;}//返回栈顶元素,这个简单,遍历栈明白了,这个也就明白了Status GetTop(SqStack *S,SElemType *e){if(S->base == S->top){printf("栈空!\n");return ERROR;}//记好,返回栈顶元素时,不对栈做任何操作,//仅仅是取栈顶元素,栈顶的指针还是指向原来的地方的//有的学生写成S->top = S->top - 1 ,把栈顶指针减1的,这是不对的//把栈顶元素的值赋给ee=*(S->top-1);return OK;}//遍历栈:Status visitStack(SqStack *S){int i;int jsq = 0;if(S->base == S->top){return ERROR;}printf("元素出栈的顺序是:\n");while(S->top - S->base > 0){S->top = S->top - 1;//这是将计时器加1,因为在遍历的时候,将栈顶指针下移了//当遍历完成后,还需要将栈顶指针还原jsq = jsq + 1;//输出栈的元素printf("%d \n",*S->top);}//将栈顶指针还原S->top = S->top + jsq;return OK;}//222222222222222222222222222第二部分结束2222222222222222222222222222//33333333333333333333333333333第三部分3333333333333333333333333333 void main(){SqStack Ss;SElemType e;int temp;int returnvalue;printf("1:初始化栈------------------------------2:往栈顶中插入元素\n"); printf("3:从栈顶取元素-------------------4:获取栈顶元素\n");printf("5:退出\n");while(1){printf("请输入要操作的编号:\n");scanf("%d",&temp);//如果是1表示头插法建立链表if(temp == 1){InitStack(&Ss);}//如果是2尾插法建立链表if(temp == 2){printf("请输入要往栈顶插入的元素值:\n");scanf("%d",&e);//入栈操作returnvalue = Push(&Ss,e);if(returnvalue == 1){visitStack(&Ss);}}//如果是3从栈顶指针取元素if(temp == 3){//调用出栈的函数returnvalue = Pop(&Ss,&e);if(returnvalue == 1){printf("你删除的栈顶元素是:%d\n",e);visitStack(&Ss);}elseprintf("栈空了!\n");}//如果是4获取指定位置的链表元素if(temp == 4){returnvalue = GetTop(&Ss,&e);if(returnvalue == 1){printf("你获取的栈顶元素是:%d\n",e);visitStack(&Ss);}}//操作结束if(temp == 5){exit(1);}} }。

数据结构-栈

数据结构-栈

数据结构-栈⼀、栈1. 1. 为什么要学习栈?栈是什么?为什么要学习它?现在先来说说栈的辉煌作⽤吧!在计算机领域中,栈是⼀种不可忽略的概念,⽆论从它的结构上,还是存储数据⽅⾯,它对于学习数据结构的⼈们来说,都是⾮常重要的。

那么就会有⼈问,栈究竟有什么作⽤,让我们这么重视它?⾸先,栈具有⾮常强⼤的“记忆”功能,它可以保存对你有作⽤的数据,也可以被叫做保存现场;其次,当咱们调⽤⼀个带参函数时候,被调⽤的函数的形参,在编译器编译的时候,这些形参都需要⼀定的空间存放他们,这时计算机就会默认帮你保存到栈中了!1. 2. 栈的定义栈的作⽤,这是⼀个咱们⽣活中处处⽤到,但是却⼜没发现的⼀种现象,例如当你拿个篮⼦去买苹果,那么你最先挑选的苹果就是在篮⼦的最底下,最后挑选的苹果就在篮⼦的最上边,那么这就造成了这么⼀种现象:先拿进篮⼦的苹果,要最后才能取出来;相反,最后拿进篮⼦的苹果,就能最先取出来!栈是限定只能在表尾进⾏插⼊和删除的线性表。

我们把允许插⼊和删除的⼀端称作栈顶(Top),另⼀端称作栈底(bottom)。

不含任何数据元素的栈被称作空栈,栈也被称为先进后出的线性表(具有线性关系)。

⽽栈的特殊性,就是在表中想进⾏插⼊和删除的操作,只能在栈顶进⾏。

这也就使得了:栈底是⾮常稳定的,因为先进来的元素都被放在了栈底。

栈的插⼊操作:叫做进栈,也叫作压栈,⼊栈。

栈的删除操作:叫做出栈,也叫弹栈。

1. 3. 进栈出栈变化形式现在请⼤家思考这样的⼀个问题:最先进栈的元素,是不是只能最后才能出来呢?答案是不⼀定的,这个问题就要细分情况了。

栈对线性表的插⼊和删除的位置进⾏了限制,并没有对元素的进出时间进⾏限制,这也就是说,在不是所有元素都进栈的情况下,事先进去的元素也可以先出站,只要确保⼀点:栈元素是从栈顶出栈就可以了!举例来说,现在有3个整型数元素1、2、3依次进栈,会有哪些出栈次序呢?第⼀种:1、2、3依次进,再3、2、1依次出栈。

数据结构与算法:Python语言描述 栈和队列 ppt课件

数据结构与算法:Python语言描述 栈和队列  ppt课件

裘宗燕,2019/12/22-/10/
栈的应用
栈是算法和程序里最常用的辅助结构,基本用途基于两方面: 用栈可以很方便地保存和取用信息,因此常作为算法或程序里的辅 助存储结构,临时保存信息,供后面的操作使用 利用栈后进先出的特点,可以得到特定的存储和取用顺序 许多实际运用结合了这两方面的特性
配对的原则
遇到的闭括号应该匹配此前遇到的最近的尚未匹配的对应开括号
由于多种/多次/可能嵌套,为检查配对,遇到的开括号必须保存
由于括号可能嵌套,需要逐对匹配,闭括号应与前面最近的尚未有 匹配的开括号匹配,后面括号应与更前面次近的括号匹配
可以删除匹配的括号,为后面的匹配做好准备
后遇到并保存的开括号应该先删除,这就是后进先出,而且要按照出现 顺序,显然应该/可以用一个栈保存开括号
概述
栈和队列保证元素存取之间的时间关系,特点是:
栈是保证缓存元素后进先出(Last In First Out,LIFO)的结构
队列是保证缓存元素的先进先出(先存者先用,First In First Out, FIFO)关系的结构
对于栈和队列,任何时候,下次访问或删除的元素都默认地唯一确定。 只有新的存入或删除(弹出)操作可能改变下次的默认元素
self._elems = [] # 所有栈操作都映射到list操作
def is_empty(self):
return self._elems == []
def top(self):
if self._elems == []:
raise StackUnderflow("in SStack.top()")
return self._elems[-1]

数据区,代码区,堆区,栈区

数据区,代码区,堆区,栈区

一般全句变量存放在数据区,局部变量存放在栈区,动态变量存放在堆区,函数代码存放在代码区。

栈区是普通的栈数据结构。

遵循LIFO后进先出的规则。

局部变量安排在那里可以在一个函数结束后平衡堆栈,操作简单,效率高。

堆区这里应该叫堆栈(不要和数据结构中的堆搞混),是程序在编译时产生的一块用于产生动态内存分配使用的块。

操作比较栈要麻烦许多。

在分配时要判断最优的地址(防止产生无用的内存碎片(由于屡次的NEW和DELETE产生的夹在两块使用中内存中的空余小内存(不容易分配)))。

分配和回收时的效率比栈低多了。

栈是系统提供的功能,特点是快速高效,缺点是有限制,数据不灵活;而堆是函数库提供的功能,特点是灵活方便,数据适应面广泛,但是料率有一定降低。

栈是系统数据结构,对于进程/线程是唯一的;堆是函数库内部数据结构,不一定唯一。

不同堆分配的内存无法相互操作。

栈空间分静态分配和动态分配两种。

静态分配是编译器完成的,比如自动变量的分配。

动态分配由malloc函数完成。

栈的动态分配无需释放(是自动的),也就没有释放函数。

为可移植程序起见,栈的动态分配操作是不被鼓励的。

堆空间的分配总是动态的,虽然程序结束时所有的数据空间都会被释放回系统,但是精确的申请内存/释放内存是良好程序的基本要素。

举个例子说明这些“段”的区别:#include<malloc.h>Unsigned char gvch;Unsigned char gvshort;Unsigned int gvint=71328;Unsigned long gvlong=427399;V oid main(){Unsigned char array[10],*p;P=malloc(10*sizeof(char));While(1);}以上程序中代码是存放在代码区中,比如while(1);Gvch与gvshort两个全局变量由于没有赋初值存放在:bss段中Gvint与gvlong两个全局变量赋初值了存放在:数据段中Array数组与p变量wieiqwo局部变量存放在:栈区Malloc函数申请的空间是属于动态的存放在:堆区。

C语言数据结构_第04讲 栈

C语言数据结构_第04讲 栈

while(n); printf("转换后的二进制数值为:"); while(s.top) // 余数出栈处理 { printf("%d",s.top->data); // 输出栈顶的余数 stacknode* p=s.top; // 修改栈顶指针 s.top=s.top->next; delete p; // 回收一个结点,C语言中用free p } }
3-3-2 表达式求值
表达式是由运算对象、运算符、括号等组成的有意义的式子。 1.中缀表达式(Infix Notation) 一般我们所用表达式是将运算符号放在两运算对象的中 间,比如:a+b,c/d等等,我们把这样的式子称为中缀表达 式。 2.后缀表达式(Postfix Notation) 后缀表达式规定把运算符放在两个运算对象(操作数) 的后面。在后缀表达式中,不存在运算符的优先级问题,也 不存在任何括号,计算的顺序完全按照运算符出现的先后次 次序进行。 3.中缀表达式转换为后缀表达式 其转换方法采用运算符优先算法。转换过程需要两个栈: 一个运算符号栈和一个后缀表达式输出符号栈。
(4)读栈顶元素
datatype ReadTop(SeqStack *s) { if (SEmpty ( s ) ) return 0; // 若栈空,则返回0 else return (s->data[s->top] );
// 否则,读栈顶元素,但指针未移动
}
(5)判栈空
int SEmpty(SeqStack *s) { if (s->top= = –1) return 1; else return 0; }
2.顺序栈运算的基本算法 (1)置空栈 首先建立栈空间,然后初始化栈顶指针。 SeqStack *Snull() { SeqStack *s; s=new (SeqStack);

C++数据结构 第1章 栈(C++版)

C++数据结构 第1章  栈(C++版)

case '-':number[p]-=number[p + 1];break; case '*':number[p]*=number[p + 1];break; case '/':number[p]/=number[p + 1];break; } } bool can() //判断运算符的优先级别,建立标志函数 { if ((s[i]=='+'||s[i]=='-')&&symbol[p]!='(') return 1; if ((s[i]=='*'||s[i]=='/')&&(symbol[p]=='*'||symbol[p]=='/'))return 1; return 0; } main() { printf("String :");gets(s); s[strlen(s)]=')';symbol[p]='('; while (i<strlen(s))
main() { ("input a string(@_over):"); gets(s); printf("result=%d",comp(s)); system("pause"); return 0; }
栈的用途极为广泛,在源程序编译中表达式的计算、过程的嵌套调用和递 归调用等都要用到栈,下面以表达式计算为例子加以说明。 源程序编译中,若要把一个含有表达式的赋值语句翻译成正确求值的机器 语言,首先应正确地解释表达式。例如,对赋值语句 X=4+8×2-3; (式 11.1) 其正确的计算结果应该是17,但若在编译程序中简单地按自左向右扫描 的原则进行计算,则为:X=12×2-3=24-3=21 这结果显然是错误的。因此,为了使编译程序能够正确地求值,必须事先 规定求值的顺序和规则。通常采用运算符优先数法。 一般表达式中会遇到操作数、运算符和语句结束符等,以算术运算符为例, 对每种运算赋予一个优先数,如: 运算符:× ÷ + - 优先数:2 2 1 1 (语句结束符“;”的优先数为零) 在运算过程中,优先数高的运算符应先进行运算(但遇到括号时,应另作 处理)。按这样的规定,对式(11.1)自左向右进行运算时,其计算顺序就被 唯一地确定下来了。计算顺序确定后,在对表达式进行编译时,一般设立两个 栈,一个称为运算符栈(OPS),另一个称为操作数栈(OVS),以便分别存 放表达式中的运算符和操作数。编译程序自左向右扫描表达式直至语句结束, 其处理原则是: ①凡遇到操作数,一律进入操作数栈; ②当遇到运算符时,则将运算符的优先数与运算符栈中的栈顶元素的优先

数据结构栈代码

数据结构栈代码

在Python中,我们可以使用内置的list数据类型来实现一个栈。

下面是一个简单的栈实现:
python
class Stack:
def __init__(self):
self.stack = []
# 压栈
def push(self, item):
self.stack.append(item)
# 弹栈
def pop(self):
if not self.is_empty():
return self.stack.pop()
else:
return "Stack is empty."
# 检查栈顶元素
def peek(self):
if not self.is_empty():
return self.stack[-1]
else:
return "Stack is empty."
# 检查栈是否为空
def is_empty(self):
return len(self.stack) == 0
# 返回栈的大小
def size(self):
return len(self.stack)
这个Stack类实现了五个基本的栈操作:push,pop,peek,is_empty和size。

push方法用于将元素压入栈中,pop方法用于从栈顶弹出元素,peek方法用于查看栈顶元素,is_empty 方法用于检查栈是否为空,而size方法则返回栈中的元素数量。

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列

《数据结构》实验指导及实验报告栈和队列实验四栈和队列⼀、实验⽬的1、掌握栈的结构特性及其⼊栈,出栈操作;2、掌握队列的结构特性及其⼊队、出队的操作,掌握循环队列的特点及其操作。

⼆、实验预习说明以下概念1、顺序栈:2、链栈:3、循环队列:4、链队三、实验内容和要求1、阅读下⾯程序,将函数Push和函数Pop补充完整。

要求输⼊元素序列1 2 3 4 5 e,运⾏结果如下所⽰。

#include#include#define ERROR 0#define OK 1#define STACK_INT_SIZE 10 /*存储空间初始分配量*/#define STACKINCREMENT 5 /*存储空间分配增量*/typedef int ElemType; /*定义元素的类型*/typedef struct{ElemType *base; /*定义栈底部指针*/ElemType *top; /*定义栈顶部指针*/int stacksize; /*当前已分配的存储空间*/}SqStack;int InitStack(SqStack *S); /*构造空栈*/int push(SqStack *S,ElemType e); /*⼊栈操作*/int Pop(SqStack *S,ElemType *e); /*出栈操作*/int CreateStack(SqStack *S); /*创建栈*/void PrintStack(SqStack *S); /*出栈并输出栈中元素*/int InitStack(SqStack *S){S->base=(ElemType *)malloc(STACK_INT_SIZE *sizeof(ElemType)); if(!S->base) return ERROR;S->top=S->base;int Push(SqStack *S,ElemType e){if(S->top-S->base>=S->stacksize){S->base=(ElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(ElemType)); S->top=S->base+S->stacksize;S->stacksize+=STACKINCREMENT;}*S->top++=e;return 1}/*Push*/int Pop(SqStack *S,ElemType *e){if(S->top!=S->base){*e=*--S->top;return 1;}elsereturn 0;}/*Pop*/int CreateStack(SqStack *S){int e;if(InitStack(S))printf("Init Success!\n");else{printf("Init Fail!\n");return ERROR;}printf("input data:(Terminated by inputing a character)\n"); while(scanf("%d",&e))Push(S,e);return OK;}/*CreateStack*/while(Pop(S,&e))printf("%3d",e);}/*Pop_and_Print*/int main(){SqStack ss;printf("\n1-createStack\n");CreateStack(&ss);printf("\n2-Pop&Print\n");PrintStack(&ss);return 0;}●算法分析:输⼊元素序列1 2 3 4 5,为什么输出序列为5 4 3 2 1?体现了栈的什么特性?2、在第1题的程序中,编写⼀个⼗进制转换为⼆进制的数制转换算法函数(要求利⽤栈来实现),并验证其正确性。

数据结构C语言实现----清空、销毁一个栈

数据结构C语言实现----清空、销毁一个栈

数据结构C语⾔实现----清空、销毁⼀个栈代码如下:#include<stdio.h>#include<stdlib.h>typedef struct{char *base;char *top;int stacksize;}sqStack;////////////////////////////////////////创建⼀个栈#define STACK_SIZE 100void initstack(sqStack *stack ){stack->base = (char*)malloc( STACK_SIZE * sizeof(char));if (!stack->base){exit(0);}stack->top = stack->base;stack->stacksize = STACK_SIZE;}//////////////////////////////////////⼊栈操作#define STACK_MORE 10void Push(sqStack *stack , char c){if (stack->top - stack->base > stack->stacksize){stack->base = (char*)realloc(stack->base , (stack->stacksize + STACK_MORE) * sizeof(char));if (!stack->base){exit(0);}stack->top = stack->base + stack->stacksize;stack->stacksize = stack->stacksize + STACK_MORE;}*(stack->top) = c;stack->top++;}////////////////////////////////////////出栈操作void Pop(sqStack *stack , char *c){if (stack->base == stack->top){return;}*c = *--(stack->top);}/////////////////////////////////////////清空栈void ClearStack(sqStack *stack){stack->top = stack->base;}////////////////////////////////////////销毁⼀个栈void destoryStack(sqStack *stack){for (size_t i = 0; i < stack->stacksize; i++){free(stack->base);stack->base++;}stack->base=stack->top = NULL;stack->stacksize = 0;}int main(){sqStack stack;char c=1;printf("请安任意键创建⼀个栈...\n");getchar();initstack(&stack);printf("创建成功!\n");printf("请输⼊要压⼊栈的⼀个字符串(读取到0截⾄): ");while ((c = getchar()) != '\n'){//scanf("%c",&c);//fflush(stdin);if (c!='\n'){Push(&stack , c);}}printf("压⼊字符完成,正在打印字符串...\n");for (size_t i = 0; i < (stack.top - stack.base); i++){printf("%c",*(stack.base + i));}putchar('\n');printf("请输⼊要弹出⼏个字符:");int k;scanf("%d",&k);while (k){k--;Pop(&stack , &c);printf("字符%c已弹出!\n",c);}printf("弹出字符完成,正在打印字符串...\n");for (size_t i = 0; i < (stack.top - stack.base); i++){printf("%c",*(stack.base + i));}putchar('\n');printf("接下来你可以选择清空(输⼊1)或者销毁(输⼊2)这个栈:");scanf("%d",&k);fflush(stdin);switch (k){case 1:ClearStack(&stack);if (stack.top == stack.base){printf("清空完成!");}break;case 2:destoryStack(&stack);if(stack.base == NULL && stack.top == NULL && stack.stacksize == 0) {printf("已成功销毁!");}break;default:break;}return 0;}运⾏结果:。

手把手教你数据结构代码题 新版

手把手教你数据结构代码题 新版

数据结构是计算机科学中非常重要的一个领域,它涉及到组织、管理和存储数据的方式,以及数据之间的关系和操作。

在编程中,对数据结构的理解和应用能够帮助我们更高效地处理数据,提高代码的质量和效率。

本文将通过实际的代码题示例,手把手地教你如何运用数据结构来解决实际问题。

一、什么是数据结构?在开始解析代码题之前,我们需要先了解什么是数据结构。

数据结构是计算机存储、组织数据的方式,它主要包括线性结构和非线性结构。

线性结构包括数组、链表、栈、队列等,而非线性结构则包括树、图等。

不同的数据结构适用于不同的场景,我们需要根据实际问题的特点来选择合适的数据结构。

二、代码题示例接下来,我们就以一些常见的数据结构代码题为例,来演示如何应用数据结构来解决实际问题。

1. 题目:实现一个栈栈是一种先进后出的数据结构,我们可以利用数组或链表来实现栈。

下面是一个用数组实现栈的示例代码:```class Stack {constructor() {this.items = [];}// 向栈中压入元素push(element) {this.items.push(element);}// 从栈中弹出元素pop() {return this.items.pop();}// 查看栈顶元素peek() {return this.items[this.items.length - 1]; }// 检查栈是否为空isEmpty() {return this.items.length === 0; }// 清空栈clear() {this.items = [];}// 查看栈中元素的个数size() {return this.items.length;}}// 使用示例const stack = new Stack(); stack.push(1);stack.push(2);stack.push(3);console.log(stack.pop()); // 3 console.log(stack.peek()); // 2 console.log(stack.isEmpty()); // falseconsole.log(stack.size()); // 2```2. 题目:实现一个队列队列是一种先进先出的数据结构,我们同样可以利用数组或链表来实现队列。

C数据结构实例代码

C数据结构实例代码

C数据结构实例代码C语言是一种通用的高级程序设计语言,也是实现数据结构的一种常用语言。

下面是一些常见的数据结构的示例代码,供参考。

1. 数组(Array)```c#include <stdio.h>int maiint arr[5] = {1, 2, 3, 4, 5}; // 创建一个有5个元素的整数数组for(int i=0; i<5; i++)printf("%d ", arr[i]); // 遍历并输出数组的所有元素}return 0;```2. 链表(Linked List)```c#include <stdio.h>#include <stdlib.h>struct Nodeint data;struct Node* next;};void printList(struct Node* head)struct Node* curr = head;while(curr != NULL)printf("%d ", curr->data);curr = curr->next;}void insert(struct Node** head, int data)struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = (*head);(*head) = newNode;int maistruct Node* head = NULL;insert(&head, 5);insert(&head, 4);insert(&head, 3);insert(&head, 2);insert(&head, 1);printList(head); // 输出链表的所有元素return 0;```3. 栈(Stack)```c#include <stdio.h>#define SIZE 5int stack[SIZE];int top = -1;int isEmptreturn top == -1;int isFulreturn top == SIZE - 1;void push(int item)if(isFull()printf("Stack is full.\n");} elsestack[++top] = item;printf("Pushed %d\n", item);}void poif(isEmpty()printf("Stack is empty.\n");} elseprintf("Popped %d\n", stack[top--]); }int maipush(1);push(2);push(3);pop(;push(4);push(5);push(6);pop(;return 0;```4. 队列(Queue)```c#include <stdio.h>#define SIZE 5int queue[SIZE];int front = -1; // 队头指针int rear = -1; // 队尾指针int isEmptreturn front == -1 && rear == -1; int isFulreturn rear == SIZE - 1;void enqueue(int item)if(isFull()printf("Queue is full.\n");} elseif(isEmpty()front = rear = 0;} elserear++;}queue[rear] = item;printf("Enqueued %d\n", item);}void dequeuif(isEmpty()printf("Queue is empty.\n");} elseprintf("Dequeued %d\n", queue[front]); if(front == rear)front = rear = -1;} elsefront++;}}int maienqueue(1);enqueue(2);enqueue(3);dequeue(;enqueue(4);enqueue(5);enqueue(6);dequeue(;return 0;```5. 树(Tree)```c#include <stdio.h>#include <stdlib.h>struct Nodeint data;struct Node* left;struct Node* right;};struct Node* create(int data)struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;void inorder(struct Node* root)if(root != NULL)inorder(root->left);printf("%d ", root->data);inorder(root->right);}int maistruct Node* root = create(1);root->left = create(2);root->right = create(3);root->left->left = create(4);root->left->right = create(5);root->right->left = create(6);root->right->right = create(7);printf("Inorder traversal of the tree: "); inorder(root); // 中序遍历树return 0;```。

栈和队列 严蔚敏 数据结构(C语言版)书上 源代码、算法、例题、实例(二)清华大学

栈和队列 严蔚敏 数据结构(C语言版)书上 源代码、算法、例题、实例(二)清华大学
voidmovecharvoidhanoiint将塔座x上按直径由小到大且至上而下编号为1搬动操作move是初值为0的全局变量对搬动计数printfimovedisk将编号为1的圆盘从x移到zelsehanoin1xzy
Rar! CHAP03\ALGO0301.CPP void conversion (int Num) { // 算法 3.1 // 对于输入的任意一个非负十进制整数,打印输出与其等值的八进制数 ElemType e; SqStack S; InitStack(S); // 构造空栈 while (Num) { Push(S, Num % 8); Num = Num/8; } while (!StackEmpty(S)) { Pop(S,e); printf ("%d", e); } printf("\n"); } // conversion
return Find; }
int ReturnOpOrd(char op,char* TestOp) { int i; for(i=0; i< OPSETSIZE; i++) { if (op == TestOp[i]) return i; } return 0; } char precede(char Aop, char Bop) { return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)]; }
CHAP03\ALGO0305.CPP int Count=0; void move(char x, int n, char z); void hanoi (int n, char x, char y, char z) { // 算法 3.5 // 将塔座 x 上按直径由小到大且至上而下编号为 1 至 n 的 n 个圆盘按规则搬到 // 塔座 z 上,y 可用作辅助塔座。 // 搬动操作 move (x, n, z) 可定义为: // (c 是初值为 0 的全局变量,对搬动计数) // printf("%i. Move disk %i from %c to %c\n", ++c, n, x, z); if (n==1) move(x, 1, z); //将编号为1的圆盘从 x 移到 z else { hanoi(n-1,x,z,y); move(x, n, z); //将编号为 n 的圆盘从 x 移到 z hanoi(n-1, y, x, z); //将 y 上编号为1至 n-1 的圆盘移到 z,x 作辅助塔 } } void move(char x, int n, char z) { printf(" %2i. Move disk %i from %c to %c\n",++Count,n,x,z); }

数据结构PTA-符号配对栈

数据结构PTA-符号配对栈

数据结构PTA-符号配对栈请编写程序检查C语⾔源程序中下列符号是否配对:/*与*/、(与)、[与]、{与}。

输⼊格式:输⼊为⼀个C语⾔源程序。

当读到某⼀⾏中只有⼀个句点.和⼀个回车的时候,标志着输⼊结束。

程序中需要检查配对的符号不超过100个。

输出格式:⾸先,如果所有符号配对正确,则在第⼀⾏中输出YES,否则输出NO。

然后在第⼆⾏中指出第⼀个不配对的符号:如果缺少左符号,则输出?-右符号;如果缺少右符号,则输出左符号-?。

输⼊样例1:void test(){int i, A[10];for (i=0; i<10; i++) /*/A[i] = i;}.输出样例1:NO/*-?输⼊样例2:void test(){int i, A[10];for (i=0; i<10; i++) /**/A[i] = i;}].输出样例2:NO-]输⼊样例3:void test(){int idouble A[10];for (i=0; i<10; i++) /**/A[i] = 0.1*i;}.输出样例3:YES分析:⾸先就是把串全部读进来,合成⼀个⼤串,只保留包含符号即可读串时考虑使⽤函数getline,因为getline默认回车符停⽌读⼊,按Ctrl+Z或键⼊EOF回车即可退出循环,⽅便书写。

然后再对新⽣成的串处理:如果读⼊的是左括号,直接压⼊栈顶。

如果读⼊的是右括号:1.如果栈为空,那么缺少与之对应的左括号。

2.如果栈顶元素与之不匹配,那么缺少与栈顶元素相匹配的右括号。

对于不匹配的判断:根据ASCII表,串中元素-栈顶元素!=1且!=23.处理完之后,如果栈为空,则表⽰完全匹配,如果有剩余,那么就是缺少右括号。

因为是输出第⼀个缺少的,所以直接输出栈尾的元素就可以。

判断情况可提前设⽴⼀个flag代码#include<bits/stdc++.h>using namespace std;#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef char SElemType ;typedef struct{SElemType *base;SElemType *top;int stacksize;} STACK;int Pop(STACK &S) //出栈{if(S.top==S.base)return0;*S.top,S.top--;return1;}int Push(STACK &S,char e) //⼊栈{if(S.top-S.base>=S.stacksize){S.base = (SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));;if(!S.base){return -1;}S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return1;}int StackEmpty(STACK& S) //判断是否栈空{if(S.base == S.top)return1;return -1;}int Gettop(STACK S,SElemType &e) //返回栈顶元素{if(S.top==S.base)return0;e= *(S.top-1);return1;}int InitStack(STACK &S) //建⽴空栈S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));if(!S.base)exit(-1);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return1;}int main(){string x,y="";int flag=1;while(getline(cin,x)) //输⼊字符串{int i=0;if(x==".")break;for(; i<x.size(); i++){if(x[i]=='['||x[i]==']'||x[i]=='{'||x[i]=='}'||x[i]=='('||x[i]==')')y+=x[i];else if(x[i]=='/'&&x[i+1]=='*'){y+="<";i++;}else if(x[i]=='*'&&x[i+1]=='/') //注意:将*/视为>{y+=">";i++;}}}STACK S;InitStack(S);int i=0;for(; i<y.size(); i++){char a;Gettop(S,a);if(y[i]=='['||y[i]=='{'||y[i]=='('||y[i]=='<') //以左包含的符号起始,⼊栈{Push(S,y[i]);continue;}else if(StackEmpty(S)==1) //以右包含的符号起始,直接报错 {printf("NO\n");if(y[i]=='>')printf("?-*/\n");elseprintf("?-%c\n",y[i]);flag=0;break;}else if(y[i]-a!=1&&y[i]-a!=2){printf("NO\n");if(a=='<')printf("/*-?\n");elseprintf("%c-?\n",a);Pop(S);flag=0;i--;break;}elsePop(S);}if(flag==1){if(StackEmpty(S)==1) printf("YES\n");else{char a;Gettop(S,a);printf("NO\n");if(a=='<')printf("/*-?\n");elseprintf("%c-?\n",a); }}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

栈——代码实现
//定义顺序表:
#include <stdio.h>
#define MAXLEN 10
typedef int ElementType;
typedef struct
{
ElementType data[MAXLEN];
int top;
}SqStack;
//建空栈
SqStack InitStack()
{ SqStack s;
s.top=-1;
return(s);
}
//取栈顶元素,并用*x返回栈顶元素
int GetTopStack(SqStack *s,ElementType *x)
{
if(s->top==-1)
return(0);
else
{ *x=s->data[s->top];
return(1);
}
}
//输出栈
void PrintStack(SqStack s)
{
int i;
if(s.top!=-1)
{
printf("输出栈内的元素为:");
for(i=0;i<=s.top;i++)
printf("%3d",s.data[i]);
}
else
printf("此栈为空栈!");
printf("\n");
}
//进栈
int PushStack(SqStack *s,ElementType x)
{
if(s->top==MAXLEN-1)
return(0);
s->top++;
s->data[s->top]=x;
return(1);
}
//出栈,删除s的栈顶元素,并用*x返回栈顶元素int PopStack(SqStack *s,ElementType *x)
{ if(s->top==-1)
return(0);
*x=s->data[s->top];
s->top--;
return(1);
}
//判空栈
int IsEmptyStack(SqStack *s)
{ return(s->top==-1);}
//主程序
int main()
{ SqStack s;
int i ;
ElementType y;
ElementType z;
s=InitStack();
printf("请输入个数:\n");
for(i=1;i<=5;i++)
{ scanf("%d",&y);
PushStack(&s,y); }
PrintStack(s);
GetTopStack(&s,&z);
printf("栈顶元素为:%d",z);
printf("出栈个元素:");
for(i=1;i<=3;i++)
{ PopStack(&s,&z);
printf("%3d",z); }
printf("\n");
PrintStack(s);
}
栈——代码实现
#include <stdio.h>
#include "malloc.h" //使用malloc标识符必须加此代码typedef int ElementType;
typedef struct node
{
ElementType data;
struct node *next;
}NODE;
//建一个空栈
NODE *CreateSqStackLink()
{
NODE *s;
s=(NODE *)malloc(sizeof(NODE));
s->next=0;
return(s);
}
//进栈
void PushSqStackLink(NODE *s,ElementType x)
{
NODE *p;
p=(NODE *)malloc(sizeof(NODE));
p->data=x;
p->next=s->next;
s->next=p;
}
//输出栈
void PrintSqStackLink(NODE *s)
{
NODE *p;
p=s->next;
if(p!=NULL)
{
printf("输出栈的元素为:");
while(p!=NULL)
{
printf("%3d",p->data);
p=p->next;
}
}
else
printf("此栈为空!");
printf("\n"); }
//出栈
int PopSqStackLink(NODE *s)
{
ElementType t;
NODE *p;
p=s->next;
if(p==0)
return(0);
else
{
s->next=p->next;
t=p->data;
free(p);
return(t);
}
}
//主程序
void main()
{
int i,j;
ElementType a;
NODE *s;
s=CreateSqStackLink();
printf("请输入进栈元素个数:");
scanf("%d",&i);
for(j=1;j<=i;j++)
{
printf("请输入第%d个数:",j);
scanf("%d",&a);
PushSqStackLink(s,a);
}
PrintSqStackLink(s);
a=PopSqStackLink(s);
printf("出栈元素为:%d",a);
}。

相关文档
最新文档