线性结构——栈、队列

最新推荐文章于 2022-11-27 12:39:18 发布
最新推荐文章于 2022-11-27 12:39:18 发布
阅读量478 收藏 1
点赞数
文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangliang19950813/article/details/121268696
版权

一、栈

栈是一种只能从表的一端存取数据且遵循 “先进后出” 原则的线性存储结构。

  • 向栈中添加元素，此过程被称为"进栈"（入栈或压栈）；
  • 从栈中提取出元素，此过程被称为"出栈"（或弹栈）；
  • 栈的开口端被称为栈顶；封口端被称为栈底
    在这里插入图片描述
    如图，1最先进栈，4最先出栈

栈的具体实现

实现分为 顺序栈 和 链栈

  • 顺序栈：采用顺序存储结构可以模拟栈存储数据的特点，从而实现栈存储结构；
  • 链栈：采用链式存储结构实现栈结构；

1.1 顺序栈

可以用数组或者连续内存，本文使用连续内存。
在这里插入图片描述

1.1.1 定义数据类型

typedef struct
{
  datatype *bottom;  // 栈底指针
  int size;          // 栈容量
}stack_o;

1.1.2 初始化栈

stack_o *Init_stack_o (void)  //初始化栈
{
  stack_o *stack = NULL;

  stack = malloc (sizeof (stack_o));

  stack->bottom = malloc (STACK_MAXSIZE * sizeof (datatype));
  stack->size = 0;
  
  return stack;
}

1.1.3 判空

int isempty_stack_o (stack_o *stack) //判空
{
  //检查参数

	return  stack->size == 0? 1 : 0;
}

1.1.4 判满

int isfull_stack_o(stack_o *stack) //判满
{
  //检查参数
  
	return stack->size == STACK_MAXSIZE ? 1 : 0;
}

1.1.5 入栈

int push_stack_o (stack_o *stack, datatype data) //入栈
{
  if (isfull_stack_o(stack)) {
    printf ("stack is null! \n");
    return -1;
  }

  stack->bottom[stack->size++] = data;

  return 0;
}

1.1.6 出栈

int pop_stack_o (stack_o *stack) //出栈
{
  if (isempty_stack_o(stack)) {
    printf ("stack is full! \n");
    return -1;
  }
  
  stack->bottom[stack->size--] = 0;

  return 0;
}

1.1.7 打印

int display_stack_o (stack_o *stack) //打印
{
  int i;
  
  printf ("stack bottom: ");
  for (i = 0; i < stack->size; i++) {
    printf ("%d - %p --> ",stack->bottom[i], &stack->bottom[i]);
  }
  printf ("\n");

  return 0;
}

1.1.8 销毁栈

int destory_stack_o (stack_o *stack)   //销毁栈
{
  //检查参数
  
  free (stack->bottom);
  free (stack);
}

1.1.9 测试

int main(void)
{
  datatype data[5] = {5, 4, 1, 3, 2};
  stack_o *stack = NULL;
  stack = Init_stack_o();

  if (isempty_stack_o (stack)) {
    printf ("stack is null\n");
  }

  push_stack_o (stack, data[0]);
  push_stack_o (stack, data[1]);
  push_stack_o (stack, data[2]);
  push_stack_o (stack, data[3]);
  push_stack_o (stack, data[4]);
  display_stack_o (stack);

  pop_stack_o (stack);
  display_stack_o (stack);

	return 0;
}

在这里插入图片描述

1.2 链栈

在这里插入图片描述

1.2.1 定义数据类型

typedef int datatype;

typedef struct stack
{
  struct stack *next;     // 指针域
  datatype     data;      // 数据
}stack_l;

1.2.2 初始化栈

stack_l *create_stack_l (void)  //创建头节点
{
  stack_l *head = NULL;
  head = malloc(sizeof(*head));
	
	head->next=NULL;

	return head;
}

1.2.3 判空

int isempty_stack_l (stack_l *head) //判空
{
  return head->next == NULL ? 1 : 0;
}

1.2.4 入栈

int push_stack_l (stack_l *head, datatype data)  //入栈
{
  stack_l *stack = NULL;
  stack_l *q = NULL;

  stack = malloc (sizeof (stack_l));
  memcpy (&stack->data, &data, sizeof (datatype));

  for(q = head; q->next != NULL; q = q->next);
	q->next = stack;
  stack->next = NULL;
  
  return 0;
}

1.2.5 出栈

int pop_stack_l (stack_l *head)  //出栈
{
  stack_l *tmp = NULL;
  for (tmp = head; tmp->next->next != NULL; tmp=tmp->next);

  free(tmp->next);

  tmp->next = NULL;
  
  return 0;
}

1.2.6 打印

int display_stack_l (stack_l *head) //打印
{
  stack_l *q = NULL;
  printf ("head : %p -> ",head);
  for (q = head->next ; q != NULL ; q = q->next) {
    printf ("%d - %p -> ",q->data,q);
  }
  printf ("\n");

  return 0;
}

1.2.7 销毁栈

int destory_stack_l (stack_l *head) //销毁栈
{
  stack_l *q,*p;
  
  for (p = head->next, q = p; q != NULL; q = p) {
    p = q->next;
    q->next = NULL;
    free (q);
  }
  
  head->next = NULL;

  free (head);
  head = NULL;

  return 0;
}

1.2.8 测试

int main(void)
{
  datatype data[5] = {5, 4, 1, 3, 2};
  stack_l *head = NULL;
  head = create_stack_l();

  if (isempty_stack_l (head)) {
    printf ("stack is null\n");
  }

  push_stack_l (head, data[0]);
  push_stack_l (head, data[1]);
  push_stack_l (head, data[2]);
  push_stack_l (head, data[3]);
  push_stack_l (head, data[4]);
  display_stack_l (head);

  pop_stack_l (head);
  display_stack_l (head);
  pop_stack_l (head);
  display_stack_l (head);
  
  destory_stack_l (head);

	return 0;
}

在这里插入图片描述

二、队列

队列中数据的进出要遵循 “先进先出” 的原则

  • 向队列中添加元素，此过程被称为入队；
  • 从队列中提取出元素，此过程被称为出队；
  • 出队 口被称为 队头；入队 口被称为 队尾

在这里插入图片描述

队列的具体实现

实现分为 顺序队列 和 链队列

  • 顺序队列：在顺序表的基础上实现的队列结构；
  • 链式队列：在链表的基础上实现的队列结构；

2.1 顺序队列

在这里插入图片描述

2.1.1 定义数据类型

typedef int datatype;

typedef struct {
  datatype *data;  //数据域指针
  int front;       //队头
  int rear;        //队尾
}queue_o;

2.1.2 初始化队列

queue_o *Init_queue_o (void)  //初始化队列
{
  queue_o  *queue = NULL;

  queue = malloc (sizeof (queue_o));
  queue->data = malloc (QUEUE_MAXSIZE * sizeof (datatype));
  queue->front = 0;
  queue->rear = 0;

  return queue;
}

2.1.3 判空

int isempty_queue_o (queue_o *queue) //判空
{
  //检查参数

	return  queue->front == 0? 1 : 0;
}

2.1.4 判满

int isfull_queue_o(queue_o *queue) //判满
{
  //检查参数
  
	return queue->front == QUEUE_MAXSIZE ? 1 : 0;
}

2.1.5 入队

int push_queue_o (queue_o *queue, datatype data) //入队
{
  queue->data[queue->rear++] = data;

  return 0;
}

2.1.6 出队

int pop_queue_o (queue_o *queue) //出队
{
   int i;

  for (i = queue->front; i < queue->rear; i++) {
    queue->data[i] = queue->data[i + 1];
  }
  
  queue->rear--;

  return 0;
}

2.1.7 打印

int display_queue_o (queue_o *queue) //打印
{
  int i;
  
  printf ("queue head: ");
  for (i = queue->front; i < queue->rear; i++) {
    printf ("%d - %p --> ",queue->data[i], &queue->data[i]);
  }
  printf ("queue tail\n");

  return 0;
}

2.1.8 销毁队列

int destory_stack_o (queue_o *queue)   //销毁队列
{
  //检查参数
  
  free (queue->data);
  free (queue);
}

2.1.9 测试

int main(void)
{
	datatype data[5] = {1, 2, 3, 4, 5};
  queue_o *queue = NULL;
  queue = Init_queue_o();

  if (isempty_queue_o (queue)) {
    printf ("queue is null\n");
  }

  push_queue_o (queue, data[0]);
  push_queue_o (queue, data[1]);
  push_queue_o (queue, data[2]);
  push_queue_o (queue, data[3]);
  push_queue_o (queue, data[4]);
  display_queue_o (queue);

  pop_queue_o (queue);
  display_queue_o (queue);

	return 0;
}

在这里插入图片描述

2.2 链式队列

在这里插入图片描述

2.2.1 定义数据类型

typedef int datatype;

typedef struct queue
{
  struct queue *next;     // 指针域 队头
  datatype     data;      //数据
}queue_l;

2.2.2 初始化队列

queue_l *create_queue_l (void)  //创建头节点
{
  queue_l *head = NULL;
  head = malloc(sizeof(*head));
	
	head->next=NULL;

	return head;
}

2.2.3 判空

int isempty_queue_l (queue_l *head) //判空
{
  return head->next == NULL ? 1 : 0;
}

2.2.4 打印

int display_queue_l (queue_l *head) //打印
{
  queue_l *q = NULL;
  printf ("tail : %p -> ",head);
  for (q = head->next ; q != NULL ; q = q->next) {
    printf ("%d - %p -> ",q->data,q);
  }
  printf ("\n");

  return 0;
}

2.2.5 入队

int push_queue_l (queue_l *head, datatype data)  //入队
{
  queue_l *queue = NULL;
  queue_l *q = NULL;

  queue = malloc (sizeof (queue_l));
  memcpy (&queue->data, &data, sizeof (datatype));

  for(q = head; q->next != NULL; q = q->next);
	q->next = queue;
  queue->next = NULL;
  
  return 0;
}

2.2.6 出队

int pop_queue_l (queue_l *head)  //出队
{
  queue_l *tmp = NULL;

  for (tmp = head; tmp->next->next != NULL; tmp=tmp->next);

  free(tmp->next);

  tmp->next = NULL;
  
  return 0;
}

2.2.7 销毁队列

int destory_queue_l (queue_l *head) //销毁队列
{
  queue_l *q,*p;
  
  for (p = head->next, q = p; q != NULL; q = p) {
    p = q->next;
    q->next = NULL;
    free (q);
  }
  
  head->next = NULL;

  free (head);
  head = NULL;

  return 0;
}

2.2.8 测试

int main(void)
{
  datatype data[5] = {5, 4, 1, 3, 2};
  queue_l *head = NULL;
  head = create_queue_l();

  if (isempty_queue_l (head)) {
    printf ("queue_l is null\n");
  }

  push_queue_l (head, data[0]);
  push_queue_l (head, data[1]);
  push_queue_l (head, data[2]);
  push_queue_l (head, data[3]);
  push_queue_l (head, data[4]);
  display_queue_l (head);

  pop_queue_l (head);
  display_queue_l (head);
  pop_queue_l (head);
  display_queue_l (head);
  
  destory_queue_l (head);
  
  return 0;
}

在这里插入图片描述

Mr.小张
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
栈和队列都是限制存取点的线性结构_数据结构一览 - 线性结构
weixin_39662462的博客
11-23 3353
PS: 由于公众号本身的限制，有些链接无法给出，需要的可以阅读原文查看。这篇文章不是讲解数据结构的文章，而是结合现实的场景帮助大家 理解和复习数据结构与算法，如果你的数据结构基础很差，建议先去看一些基础教程，再转过来看。本篇文章的定位是侧重于前端的，通过学习前端中实际场景的数据结构，从而加深大家对数据结构的理解和认识。线性结构数据结构我们可以从逻辑上分为线性结构和非线性结构。线性结构有数组，栈，链...
栈和队列都是限制存取点的线性结构_数据结构基础-栈和队列
weixin_39636608的博客
12-01 2973
栈和队列的逻辑结构与线性表相同，其特点在于运算有所限制(运算受限的线性表)，栈操作按照后进先出(LIFO)的规则，队列按先进先出(FIFO)的规则。栈通过访问它的一端来实现数据存储与检索的线性结构。进行插入和删除操作的一端称为栈顶(Top)，另一端称为栈底(Bottom)，不包含数据元素的栈，称为空栈。运算过程：初始化栈->判断栈是否为空->入栈(Push)->出栈(Pop)-&...
数据结构——线性结构篇（线性表、堆栈、队列）
m0_66881249的博客
11-27 1143
初级数据结构的线性结构基本知识和相关代码
线性结构---栈和队列
小S的博客
10-13 978
线性结构---栈和队列
数据结构_线性结构_栈与队列
程序人生
10-11 368
数据结构之线性结构中栈与队列的基本操作。
线性结构 -- 栈和队列
柳絮
10-18 3099
线性结构 – 栈和队列 线性结构是一个有序数据元素的集合。 常用的线性结构有：线性表，栈，队列，双队列，数组，串。 常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。 特征： 1．集合中必存在唯一的一个"第一个元素"； 2．集合中必存在唯一的一个"最后的元素"； 3．除最后元素之外，其它数据元素均有唯一的"后继"； 4．除第一元素之外，其它数据元素均有唯一的"前驱"。 数据结构...
【数据结构】栈和队列详细分析（全）
热门推荐
码农研究僧的博客
05-05 1万+
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表， 其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。 栈的定义与特点 栈是限定仅在表尾进行插入或删除操作的线性表。 表尾称为栈顶,表头端称为栈底 。不含元素的空表称为空栈。栈的修改是按后进先出的原则进行的。 栈的操作 队列的定义与特点 和栈相反，队列是一种先进先出的线性表。它只允许在表的一端进行插入，而在另一端删除元素，允许插入的一端称为队尾，允许删除的一端则称为队头。 ...
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
数据结构实验报告(C++) 实验一 线性结构实验指导 程序源码
03-27
一、线性结构实验（1）——线性表 题目1....二、线性结构实验（2）——栈和队列 题目1. 队列元素倒置 题目2. 双端顺序栈 虽然不一定是对的,但是可供参考 其中可能有一部分没有完成,因为作者也确实不会
数据结构实验报告(C++) 实验一 线性结构实验指导
01-04
一、线性结构实验（1）——线性表 题目1. 顺序表的差集 题目2. 单链表的递增差集 题目3.(选做题)：不带头...二、线性结构实验（2）——栈和队列 题目1. 队列元素倒置 题目2. 双端顺序栈 虽然不一定是对的,但是可供参考
华南 数据结构上机实验代码 完整代码
04-04
栈的应用——进制转换 括号匹配检验 行编辑程序 表达式求值 队列的应用——银行客户平均等待时间 计算next值 KMP算法 二叉树的构建及遍历操作 实现二叉排序树的各种算法(1) 实现二叉排序树的各种算法(2) ...
AcWing算法基础课模板大全
07-14
栈与队列：单调队列、单调栈 kmp Trie 并查集 堆 Hash表 搜索与图论 —— 代码模板链接 常用代码模板3——搜索与图论 DFS与BFS 树与图的遍历：拓扑排序 最短路 最小生成树 二分图：染色法、匈牙利算法 数学知识 ...
线性结构（栈和队列）
小海子的博客
12-28 503
栈 先进后出 public class MyStack { private int[] elememts; public MyStack() { this.elememts = new int[0]; } /** * 获取大小 * * @return */ public int size() {...
栈和队列都是限制存取点的线性结构_栈的练习以及解析
weixin_39588911的博客
12-03 3273
The Practice Of Stack栈的练习01栈是()。A.顺序存储的线性结构 B.链式存储的非线性结构C.限制存取点的线性结构 D.限制存储点的非线性结答案：B解析：线性表、栈和队列的逻辑结构都是相同的，都属于线性结构，只是它们对数据的运算不同，从而表现出不同的特点。02()不是栈的基本操作。A.删除栈顶元素 B.删除栈底元素C.判断栈是否为空 ...
线性表、链表、栈、队列的关系
奋斗的程序猿的博客
05-16 1万+
程序员在编程实战操作面前有两个拦路虎，第一个是用递归的思想去解决问题，第二个是数据结构与算法的应用。对于递归，由于其神奇的薄面纱总是然我们觉得难以理解，而大多数递归解法还是需要承担一定的计算负担的，因此我觉得能理解其思想与用法固然好，但是实在无法理解也只能慢慢适应。而对于第二个难题，数据结构与算法基本上每一个程序员都需要了解，因为，算法是解答一个问题的基本逻辑，如果你可以证明这个逻辑是正确的，那接下来的问题就是应该采用什么样的数据结构来保证你的程序能有最高的执行效率，即比较好的时间复杂性，同样内存空间消耗也
栈和队列都是限制存取点的线性结构_数据结构与算法
weixin_39883260的博客
11-22 3683
大学课本课后答案目录：300多本大学经典教材课本课后答案&考研历年真题【单选题】1.在数据结构中,从逻辑上可以把数据结构分成( C)。A、动态结构和静态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构【单选题】2. 在数据结构中,从存储结构上可以将之分为( B)。A、动态结构和静态结构B、顺序存储和非顺序存储C、紧凑结构和非紧凑结构D、线性结构和非线性结...
栈和队列都是什么结构_数据结构与算法-栈与队列
weixin_35625676的博客
01-29 6741
使用抽象数据类型可以帮助我们更好的理解数据所需的操作，之后再进行具体的数据类型实现。实际上，往往是操作影响着我们决定数据类型该如何实现，这里有两种典型的数据结构-栈和队列。本质上，栈和队列都是线性表，只是根据操作的需求我们人为地在线性表上加上限制，形成了两种具有独特功能的数据结构。1、栈首先，普通的线性表实现是有两个端口可以访问的，但是如果作为栈就要封闭一端，只能访问另一端。这当然不是自讨苦吃，栈...
栈和队列都是什么结构_数据结构-栈和队列.md
weixin_36326053的博客
01-27 3250
栈与队列数据结构概述栈是限定仅在表尾进行插入和删除操作的线性表； 队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表;1 栈允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom),不含任何数据元素的栈称为空栈。栈又称为后进先出的线性表，栈的数据存储结构分为以下两种。 栈的抽象数据类型分为顺序栈和链式栈两种,栈接口的继承和实现关系如下图 1.1 栈的顺序存储结构(顺序栈)...
数据结构试验——栈的基本操作
最新发布
10-07
栈是一种具有特定操作顺序的线性数据结构，遵循"后进先出"（Last In First Out，LIFO）的原则。栈的基本操作包括初始化、入栈、出栈、输出、销毁、置栈空、求栈长、判顺序栈是否为空、栈满以及取栈顶元素。 初始化...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值