数据结构5-栈

最新推荐文章于 2023-11-11 00:10:14 发布
最新推荐文章于 2023-11-11 00:10:14 发布
阅读量89 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54591377/article/details/125608337
版权

栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。

栈(stack)

在这里插入图片描述
1.定义：限定只能在表的一端进行插入和删除操作运算的线性表(只能在栈顶操作)

2.逻辑结构：同线性表一样栈元素具有线性关系即前驱后继关系(一对一)

3.存储结构：顺序栈和链栈均可，顺序栈更常见

4.运算规则：只能在栈顶运算，且访问结点时依照后进后出的原则(LIFO)

5.实现方式：关键是编写入栈和出栈函数具体实现依顺序栈和链栈的不同而不同

栈和线性表唯一的区别在于运算规则。线性表插入删除位置任意而栈只能对表尾(栈顶)的元素进行插入和删除操作。(后进先出的原则)

  • 表尾an端为栈顶Top

  • 表头a1端栈底Base(Bottom)

  • 不含元素的空表称为空栈。

  • 插入元素到栈顶(表尾)的操作叫入栈(压栈)PUSH

  • 从栈顶(表尾)删除最后一个元素的操作称为出栈(弹栈)POP

栈的基本操作

  1. 栈SS的初始化操作。
    void InitStack(SS);
  2. 销毁栈SS。
    void DestroyStack(SS);
  3. 清空栈。
    void Clear(SS);
  4. 元素入栈，返回值：0-失败；1-成功。
    int Push(SS,ee);
  5. 元素出栈，返回值：0-失败；1-成功。
    int Pop(SS,ee);
  6. 判断栈是否为空，返回值：1-空，0-非空或失败。
    int IsEmpty(SS);
  7. 判断栈是已满，返回值：1-已满，0-未满或失败。
    int IsFull(SS);
  8. 求栈的长度，返回栈SS元素的个数。
    int Length(SS);
  9. 获取栈顶元素，返回值：0-失败；1-成功。
    int GetTop ( SS , ee ) ;

在这里插入图片描述

顺序栈

//SeqStac.h顺序栈
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using std::cin;


//函数结果状态代码 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define MAXSIZE 20
//Status 是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef int ElemType;

typedef struct
{
	ElemType data[MAXSIZE];   // 用数组存储顺序栈中的元素。
	int top;                  // 栈顶指针，从0到MAXSIZE-1，-1表示空栈。
							  // 也可以从1到MAXSIZE，0表示空栈。
}SeqStack, *PSeqStack;

// 顺序栈SS的初始化操作。
Status InitStack(PSeqStack SS);

// 销毁顺序栈SS。
void DestroyStack(PSeqStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(PSeqStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(PSeqStack SS, ElemType *ee);

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS);

// 清空顺序栈。
void Clear(PSeqStack SS);

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS);

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS);

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS);

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee);

//SeqStac.cpp顺序栈
#include "SeqStack.h"

// 顺序栈SS的初始化操作。
Status InitStack(PSeqStack SS)
{	
	Clear(SS);
	return OK;
}

// 销毁顺序栈SS。
void DestroyStack(PSeqStack SS)
{
	// 静态顺序栈无需释放内存，不需要销毁操作。
	Clear(SS); // 清空顺序栈。
	return;

}

// 元素入栈，返回值：0-失败；1-成功。
int Push(PSeqStack SS, ElemType *ee)
{
	
	if ((SS == NULL) || (ee == NULL)) return ERROR;  // 检查空指针。
	if (IsFull(SS) == 1)
	{
		printf("顺序栈已满，不能插入。\n"); return 0;
	}
	SS->top++;  // 栈指针先加1。
	memcpy(&SS->data[SS->top], ee, sizeof(ElemType));  // 用数组的下标访问。												   // memcpy(SS->data+SS->top,ee,sizeof(ElemType));    // 采用指针运算也可以。
	return OK;
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(PSeqStack SS, ElemType *ee)
{
	if ((SS == NULL) || (ee == NULL)) return ERROR;  // 检查空指针。
	if (SS->top == -1) { printf("栈为空。\n"); return ERROR; }
	memcpy(ee,&SS->data[SS->top], sizeof(ElemType));
	SS->top--;
	return OK;
}

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS)
{
	if (SS == NULL) return 0; // 检查空指针。
	return SS->top + 1;
}

// 清空顺序栈。
void Clear(PSeqStack SS)
{
	if (SS == NULL) return; // 检查空指针。
	SS->top = -1;  // 栈顶指针置为-1。
	memset(SS->data, 0, sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS)
{
	if (SS == NULL) return 0;  // 检查空指针。
	if (SS->top == -1) return 1;

	return 0;
}

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS)
{
	if (SS == NULL) return ERROR; // 检查空指针。
	if (SS->top >= MAXSIZE)
	{
		return OK;
	}
	return 0;
}

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS)
{
	if (SS == NULL) return;  // 检查空指针。

	if (SS->top == -1) { printf("栈为空。\n"); return ; }

	int kk;
	for (kk = 0; kk <= SS->top; kk++)
	{
		printf("SS[%d],value=%d\n", kk, SS->data[kk]);    
		// 用数组的下标访问。
	 // printf("SS[%d],value=%d\n",kk,*(SS->data+kk));   // 采用指针运算也可以。
	}
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee)
{
	if (SS == NULL) return ERROR;  // 检查空指针。
	if (SS->top == -1) { printf("栈为空。\n"); return ERROR; }
	memcpy(ee, &SS->data[SS->top], sizeof(ElemType));  
	// 用数组的下标访问。
	// memcpy(ee,SS->data+SS->top,sizeof(ElemType));    // 采用指针运算也可以。

	return OK;
}

void test01()
{
	SeqStack SS;
	InitStack(&SS);
	printf("栈的长度是%d\n", Length(&SS));

	ElemType ee;     // 创建一个数据元素。

	printf("元素（1、2、3、4、5、6、7、8、9、10）入栈。\n");
	ee = 1;  Push(&SS, &ee);
	ee = 2;  Push(&SS, &ee);
	ee = 3;  Push(&SS, &ee);
	ee = 4;  Push(&SS, &ee);
	ee = 5;  Push(&SS, &ee);
	ee = 6;  Push(&SS, &ee);
	ee = 7;  Push(&SS, &ee);
	ee = 8;  Push(&SS, &ee);
	ee = 9;  Push(&SS, &ee);
	ee = 10; Push(&SS, &ee);

	printf("栈的长度是%d\n", Length(&SS));

	// 只查看栈顶元素的值，元素不出栈。
	if (GetTop(&SS, &ee) == 1)  printf("栈顶的元素值为%d\n", ee);

	PrintStack(&SS);

	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(&SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
}
int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
	
}

链栈

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//函数结果状态代码 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1

//Status 是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef int ElemType;

typedef struct SNode
{
	ElemType data;       // 链栈中的元素。
	struct SNode *next;  // 指向下一个结点的指针。
}SNode, *LinkStack;

// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack();

// 销毁链栈SS。
void DestroyStack(LinkStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee);

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS);

// 清空链栈。
void Clear(LinkStack SS);

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(LinkStack SS);

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS);

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee);

#include "LinkStack.h"
// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack()
{
	SNode * SS = new SNode;
	if (SS == NULL) return NULL;  // 内存不足，返回失败。
	SS->next = NULL;  // 头结点的下一结点暂时不存在，置空。
	return SS;
}

// 销毁链栈SS。
void DestroyStack(LinkStack SS)
{
	if (SS == NULL) return ;
	Clear(SS);
	if (SS)
	{
		delete SS;
	}
}

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee)
{
	if ((SS == NULL) || (ee == NULL)) return 0;  // 检查空指针。
	// 内存不足，返回失败。								
	// 考虑数据元素为结构体的情况，这里采用了memcpy的方法而不是直接赋值
	SNode * p = new SNode;
	memcpy(&p->data, ee, sizeof(ElemType));

	p->next = SS->next;
	SS->next = p;
	return OK;
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee)
{
	if ((SS->next == NULL) || (ee == NULL)) return 0;  // 检查空指针。
	SNode * p = SS->next;
	memcpy( ee,&p->data, sizeof(ElemType));

	SS->next = p->next;
	delete p;
	return OK;
}

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS)
{
	if ((SS->next == NULL) ) return 0;  // 检查空指针。
	int i = 0;
	SNode * p = SS->next;
	while (p)
	{
		i++;
		p = p->next;
	}
	return i;
}

// 清空链栈。
void Clear(LinkStack SS)
{
	if (SS == NULL) return;
	SNode * p = SS->next;
	SNode * q;
	while (p)
	{
		q = p->next;
		delete p;
		p = q;
	}
	SS->next = NULL;
}

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(LinkStack SS)
{
	if (SS == NULL)
	{
		return -1;
	}
	if (SS->next)
	{
		return 0;
	}
	return 1;
}

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS)
{
	if (SS == NULL) return;
	if (SS->next == NULL) { printf("栈为空。\n"); return; }

	int kk = 0;
	SNode *pp = SS->next;  // 从第1个结点开始。

	while (pp != NULL)
	{
		printf("SS[%d],value=%d\n", kk++, pp->data);
		pp = pp->next;
	}
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee)
{
	if (SS == NULL) return ERROR;
	if (SS->next == NULL) { printf("栈为空。\n"); return ERROR; }
	memcpy(ee, &SS->next->data, sizeof(ElemType));
	return OK;
}



void test01()
{
	LinkStack SS;     // 创建链栈。

	SS = InitStack();  // 初始化链栈。

	printf("栈的长度是%d\n", Length(SS));

	ElemType ee;     // 创建一个数据元素。

	printf("元素（1、2、3、4、5、6、7、8、9、10）入栈。\n");
	ee = 1;  Push(SS, &ee);
	ee = 2;  Push(SS, &ee);
	ee = 3;  Push(SS, &ee);
	ee = 4;  Push(SS, &ee);
	ee = 5;  Push(SS, &ee);
	ee = 6;  Push(SS, &ee);
	ee = 7;  Push(SS, &ee);
	ee = 8;  Push(SS, &ee);
	ee = 9;  Push(SS, &ee);
	ee = 10; Push(SS, &ee);

	printf("栈的长度是%d\n", Length(SS));

	if (GetTop(SS, &ee) == 1)  printf("栈顶的元素值为%d\n", ee);

	PrintStack(SS);

	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);
	if (Pop(SS, &ee) == 1)  printf("出栈的元素值为%d\n", ee);

	// 销毁链栈SS。
	DestroyStack(SS); SS = 0;  // 销毁链栈后把SS置为空，防止野指针。
}
int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
	
}```
Dev晚风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：顺序栈与链栈
qq_40657299的博客
11-13 621
栈(stack): 概念：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈是允许在同一端进行插入和删除操作的
数据结构：顺序栈和链栈
qq_41962968的博客
01-16 311
/* * 程序名：seqstack1.c，此程序演示顺序栈的实现，数据元素是整数。 * */ #include <stdio.h> #include <string.h> #define MAXSIZE 10 // 顺序栈的最大长度。 typedef int ElemType; // 自定义顺序栈的数据元素为整数。 typedef struct { ElemType data[MAXSIZE]; // 用数组存储顺序栈中的元素。 int...
数据结构：顺序栈和链式栈的实现
a2998658795的博客
08-17 722
数据结构：顺序栈和链式栈的实现
C语言实现数据结构——顺序栈与链栈
chfens的博客
04-02 2127
C语言实现顺序栈与链栈的基本功能。
数据结构 一、栈的实现
code
08-21 601
www.sourcedev.cc点击打开链接
数据结构-栈.zip_数据结构-栈
09-24
5. **自定义栈的实现**：除了使用STL的`stack`，还可以自定义栈，例如使用动态数组或链表作为底层数据结构。自定义栈的优势在于可以根据需求定制栈的行为，如增加新的操作或优化性能。 综上所述，这个压缩包提供的...
数据结构学习--栈及其应用
06-25
数据结构学习中，栈是一种非常基础且重要的结构，它被称为后进先出（LIFO，Last In First Out）的数据组织形式。在栈中，新添加的元素（压栈）会在最后，而取出元素（出栈）总是从这些新元素开始，即最先添加的元素...
数据结构-栈10
01-20
数据结构中的栈是一种重要的线性存储结构，其主要特点是遵循“先进后出”（FILO，First In Last Out）原则，即最后存入的元素最先被取出。栈的这一特性使得它在许多计算机算法和系统设计中发挥着关键作用。 1. 栈的...
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构学习-队列/栈
最新发布
04-28
### 数据结构学习——队列与栈 #### 一、队列的基本概念 队列是一种特殊的线性表，只允许在表的一端进行插入操作，在另一端进行删除操作。这种操作方式使得队列遵循先进先出（FIFO, First In First Out）的原则。...
堆栈ADT实现及应用，数据结构测试
huangdxian的博客
06-03 712
数据结构复习，题目描述： 假设栈ADT的数据元素为整数，栈ADT的实现采用顺序存储结构。现要用栈来辅助完成任意非负十进制整数到Base(Base不大于35)进制的转换。部分代码已经给出，请补充完善栈溢出处理函数和主函数。 注意：只提交需要补充的函数，其他代码不允许自己重写和修改。 **栈溢出处理函数overflowProcess：**当栈满时，将栈的空间在原来基础上扩大1倍。 主函数： 输入一个非负十进制整数n及要转换的进制Base，输出其转换后的进制形式，以及长度。输出格式如下： ($...$)10=(
栈——链栈
MADE_哒哒
02-23 369
所谓的链栈指的是采用链表为存储结构而实现的栈。 根据单链表的操作特征，选择其头部为栈的顶部，此时出栈，入栈都可以在O(1)完成。 带头结点的链表，结点的插入和删除都在其头结点之后进行。 不带头结点的链表，结点的插入和删除都在其第一个结点出进行。 而且栈是操作受限制的单链表，它对单链表的功能进行了阉割。如果对单链表理解透彻，则链栈不在话下。 如果对单链表有疑问请看另一篇博客。 https...
【数据结构】顺序栈和链栈--Stack
Z1tai的博客
11-11 1749
栈是一种线性数据结构，它的元素按照特定的顺序进行插入和删除操作。栈的插入操作称为入栈（push），删除操作称为出栈（pop）。栈可以看作是一种具有限制访问的线性表，只能在表的一端进行插入和删除操作，称为栈顶（top）, 而另一端则称为栈底（bottom）。栈是计算机科学中非常重要的数据结构，它具有简单且高效的特点。我们深入了解了栈的概念、用途、基本操作和实现细节。通过掌握栈的原理和应用，我们可以更好地理解和使用它，从而在解决实际问题时发挥其优势。
栈文档之顺序栈
二木成林
04-22 4326
采用顺序存储的栈称为顺序栈，它采用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时设定一个指针（top）指向当前栈顶元素的位置。通常采用数组来实现。
#pragma once
weixin_30827565的博客
12-29 785
【1】#pragma once这个宏有什么作用？ 为了避免同一个头文件被包含（include）多次，C/C++中有两种宏实现方式：一种是#ifndef方式；另一种是#pragma once方式。在能够支持这两种方式的编译器上，二者并没有太大的区别。但两者仍然有一些细微的区别。 【2】两者的使用方式有何区别？ 示例代码如下： 1 //方式一： 2 #ifndef __SOM...
顺序栈（最简便打印栈中元素）
qq_17807067的博客
04-01 4647
最好记，最好理解的打印栈模板，个人感觉已经是最好了，如有更好请评论~
根据入栈顺序输出所有可能的出栈顺序 （Java）
qq_42194192的博客
09-15 5909
比如入栈顺序是1,2,3，那么出栈顺序分别可以是1,2,3；1,3,2；…. import java.util.Stack; public class ss { static char[] in={'a','b','c'}; public static void main(String[] args){ fun(0,new Stack&lt;Character&gt;(),"");...
C语言实现顺序栈的创建和操作(进栈，出栈，打印等等）
热门推荐
weixin_43954729的博客
03-23 1万+
C语言实现顺序栈的创建和操作(进栈，出栈，打印等等） 往期文章地址： C语言实现顺序表的创建及基本操作 C语言实现单链表的创建及基本操作 本来我在上次的文章结尾说下一篇我想写循环链表的，今天翻开课本仔细看了看，还是想先写一下有关栈方面的知识。一方面是栈和队列正在学习，另一方面是循环链表的知识和相关的例题比较多，不好写。于是我打算从顺序栈开始着手，本以为代码过程会比较顺利，没想到还是遇到了好多问...
头歌数据结构-栈的应用
07-27
栈是一种常见的数据结构，其特点是后进先出（Last In First Out，简称LIFO）。 栈的应用非常广泛，以下是几个常见的栈的应用场景： 1. 括号匹配：栈可以用于检验表达式中的括号是否匹配。遍历表达式，当遇到左括号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值