栈和队列概念及相关实现

于 2024-07-30 15:40:17 发布
阅读量324 收藏 5
点赞数 9
分类专栏： 数据结构与算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65477256/article/details/140798280
版权

栈

在线性逻辑结构中，可以是顺序存储和链式存储两种方式，其操作可以在线性表中的任意位置实现，可能不符合实际应用需求。优化的线性表，其中包含栈和队列
（注意：一下代码均以C语言实现）

1 栈的概述

所谓的栈，也称为堆栈，是一个特殊的线性逻辑关系。只能在固定端实现栈的读写访问，其固定端称为栈顶，与之对应的另外一端称为栈底(不参与数据运算)。

栈操作特点：先进后出、后进先出；

栈的存储结构：

顺序存储结构：是一个特殊的顺序表，在连续存储空间中顺序存储，通过数据元素存储位置序号表示数据元素之间的逻辑结构关系。

链式存储结构；是一个特殊的链表，在非连续存储空间中存储数据元素，通过指针表示数据元素逻辑结构关系。

2 顺序栈

2.1 顺序栈的操作

2.1.1 顺序栈数据类型的定义
/* 栈数据元素数据类型的定义 */
typedef int data_t;

/* 动态栈数据类型的定义 */
typedef struct sqstack {
    data_t *data;        /* 连续存储空间起始地址 */
    int nmemb;            /* 顺序栈可存储数据元素个数 */
    int top;            /* 栈顶元素存储位置序号 */
} sqstack_t ;
2.1.2 创建顺序栈
sqstack_t *CreateSqStack(int mynmemb)
{
    sqstack_t *stack;
    
    /* 动态创建栈信息存储结构体空间 */
    stack = malloc(sizeof(sqstack_t));
    if (stack == NULL)
        return NULL;
    
    memset(stack, 0, sizeof(sqstack_t));
    /* 动态创建顺序栈数据元素存储空间 */
    stack->data = calloc(mynmemb, sizeof(data_t));
    if (stack->data == NULL) {
        free(stack);
        return NULL;
    }
    stack->nmemb = mynmemb;
    stack->top = -1;        
    
    return NULL;
}
2.1.3 入栈

所谓的栈，也就是栈顶插入数据。

int PushSqStack(sqstack_t *stack, data_t mydata)
{
    if (stack == NULL)
        return -1;
    /* 判断栈空间是否为满，满则入栈失败*/
    if (stack->top == stack->nmemb-1)
        return -1;
    /* 入栈 */
    stack->data[++stack->top] = mydata;
    
    return 0;
}
2.1.4 出栈
/* 出栈 */
int PopSqStack(sqstack_t *stack)
{
    if (stack == NULL)
        return -1;
        
    /* 判断栈空间是否为空 */
    if (stack->top == -1)
        return -1;
    stack->top--;    /* 出栈操作 */
    return 0;
}
2.1.5 查看栈顶元素
/* 查看栈顶元素数据 */
int GetSqStack(sqstack_t *stack, data_t *mydata)
{
    if (stack == NULL)
        return -1;
        
    /* 判断栈空间是否为空 */
    if (stack->top == -1)
        return -1;
    *mydata = stack->data[stack->top];
    
    return 0;
}
2.1.6 其它操作
/* 清空栈 */
void ClearSqStack(sqstack_t *stack)
{
    if (stack == NULL)
        return;
    stack->top = -1;
}
/* 释放栈空间 */
void DestorySqStack(sqstack_t **stack)
{
    free((*stack)->data);
    free(*stack);
    *stack = NULL;
}

2.2 顺序栈分类

顺序栈数据元素存储空间，为连续存储空间，在连续存储空间中，

  1. 可以根据栈的地址生长空间分为递增栈和递减栈

    所谓的递增栈，指的是堆栈的地址是由低地址向高地址方向生长；

    所谓的递减栈，指的是堆栈的地址是由高地址向低地址方向生长。

  2. 可以根据栈顶指针(栈顶序号位置)数据是否有效分为满栈和空栈

    所谓的满栈，指的是栈顶序号位置的数据值为有效数据值；

    入栈，先修改栈顶位置，在写入值；出栈，先读取数据值，在修改栈顶位置；

    所谓的空栈，指的是栈顶序号位置的数据值为无效数据值；

    入栈，先写入数据值，在修改栈顶位置；出栈，先向栈顶位置，在读取数据值；

3 链式栈

所谓的链式栈，是一个特殊的链表，只能在链表的一端进行操作。将**链表的头结点**作为栈顶指针。

队列

1 队列的概述

1.1 队列的概念

所谓的队列，是特殊的线性表；不能在线性表中间位置进行操作，只能在线性表的两端实现操作，此时的两端分别为队头和队尾：

  1. 队尾(rear)：只能实现数据元素的写访问（插入数据元素）；

  2. 对头(front)：只能实现数据元素的读访问（查看队头数据元素、取队头数据元素）；

    队列的特点：先进先出、后进后出。

1.2 队列的存储结构

​ 顺序存储和链式存储两种方式

2 顺序队列

所谓顺序队列，指的是队列的顺序存储结构，此时队列中的数据元素在练习内存空间中存储。

2.1 顺序队列的理解

  1. 普通的顺序队列

在这里插入图片描述

  1. 顺序循环队列

在这里插入图片描述

2.2 顺序队列的操作

2.2.1 顺序循环队列数据类型的定义
/* 数据元素数据类型的定义 */
typedef int data_t;

/* 顺序循环队列 */
typedef struct sqqueue
    data_t *data;
    int nmemb;
    int front;            /* 队头游标：存储队头元素序号 */
    int rear;            /* 队尾游标：存储队尾元素序号 */
} sqqueue_t;
2.2.2 顺序循环队列的创建
sqqueue_t *CreateSqQueue(int mynmemb)
{
    sqqueue_t *queue;
    
    /* 动态创建顺序循环队列信息存储结构体空间 */
    queue = malloc(sizeof(sqqueue_t));
    if (queue == NULL)
        return NULL;
    
    /* 动态开辟顺序循环队列数据元素存储空间 */
    queue->data = calloc(mynmemb, sizeof(data_t));
    if (queue->data == NULL) {
        free(queue);
        return NULL;
    }
    queue->nmemeb = mynmemb;
    queue->front = 0;
    queue->rear = 0;
    
    return queue;
}
2.2.3 顺序队列操作实现
/* 入队 */
int EnSqQueue(sqqueue_t *queue, data_t mydata)
{
    if (queue == NULL)
        return -1;
    /* 判断队列是否为满队列 */    
    if ((queue->rear - queue->front) % queue->nmemb == queue->nmemb -1)
        return -1;
    
    queue->data[queue->rear] = mydata;
    queue->rear = (queue->rear+1) % queue->nmemb;
    
    return 0;
}
/* 出队 */
int DeSqQueue(sqqueue_t *queue)
{
    if (queue == NULL)
        return -1;
    /* 判断队列是否为空队列 */
    if (queue->rear == queue->front)
        return -1;
    /* 出队运算 */
    queue->front = (queue->front+1) % queue->nmemb;
    return 0;
}
/* 查看队头数据元素 */
int GetSqQueue(sqqueue_t *queue, data_t *mydata)
{
    if (queue == NULL)
        return -1;
    /* 判断队列是否为空队列 */
    if (queue->rear == queue->front)
        return -1;
    
    *mydata = queue->data[queue->front];
    
    return 0;
}
/* 判断队列是否为空 */
int isEmptySqQueue(sqqueue_t *queue)
{
    return (queue->rear == queue->front);
}
/* 判断队列是否为空 */
int isFillSqQueue(sqqueue_t *queue)
{
     return ((queue->rear - queue->front) % queue->nmemb == queue->nmemb -1);
}
/* 清空队列 */
void ClearSqQueue(sqqueue_t *queue)
{
    queue->front = queue->rear = 0;
}
/* 销毁队列 */
void DestorySqQueue(sqqueue_t **queue)
{
    free((*queue)->data);
    free(*queue);
    *queue = NULL;
}

3 链式队列

所谓的链式队列，表示为队列的链式存储结构，是特殊的链表。只能在链表的两端进行访问，其中一端(链表头部)进行数据的读操作(读取队头数据元素的数据、出队操作)，另外一端(链表尾部)进行数据的写操作(入队操作)。

3.1 链式队列数据类型的定义

/* 链式队列中结点数据域的数据类型定义 */
typedef int data_t;

/* 链式队列中结点是数据类型定义 */
typedef struct node {
    data_t data;        /* 数据域 */
    struct node *next;    /* 指针域 */
} node_t;

/* 链式队列数据类型 */
typedef struct linkqueue {
    node_t * front;        /* 队头指针 */
    node_t * rear;        /* 队尾指针 */
} linkqueue_t;

3.2 链式队列的创建(初始化)

linkqueue_t *CreateLinkQueue(void)
{
    linkqueue_t *queue;
    
    /* 动态创建链式队列队头指针和队尾指针存储空间 */
    queue = malloc(sizeof(linkqueue_t));
    if (queue == NULL)
        return NULL;
        
    /* 创建无效数据结点，作为队头指针结点 */
    queue->front = malloc(sizeof(node_t));
    if (queue->front == NULL) {
        free(queue);
        return NULL;
    }
    queue->front->next = NULL;
    queue->rear = queue->front;    /* 空队列 */
    
    return queue;
}

3.3 链式队列的操作

/* 入队操作 */
int EnLinkQueue(linkqueue_t *queue, data_t mydata)
{
    node_t *q;
    
    /* 判断链式队列是否存在 */
    if(queue == NULL)
        return -1;
    /* 判断链式队列尾部结点是否存在 */
    if(queue->rear == NULL)
        return -1;
    /* 创建插入数据结点 */    
    q = malloc(sizeof(node_t));
    if (q == NULL) 
        return -1;
    memset(q, 0, sizeof(node_t));
    q->data = mydata;    /* 结点数据初始化 */
    q->next = NULL;
    queue->rear->next = q;    /* 插入结点：链表尾部结点后插入结点 */
    queue->rear = q;        /* 修改队尾指针 */
    
    return 0;
}

/* 读取队头结点数据 */
int GetLinkQueue(linkqueue_t *queue, data_t *mydata)
{    
    /* 判断链式队列是否存在 */
    if(queue == NULL)
        return -1;
    /* 判断链式队列头部结点是否存在 */
    if(queue->front == NULL)
        return -1;
    /* 判断链式队列是否为空队列 */    
    if (queue->front->next == NULL)
        return -1;
    
    *mydata = queue->front->next->data;
    
    return 0;
}

int DeLinkQueue(linkqueue_t *queue)
{
    node_t *q;
    
    /* 判断链式队列是否存在 */
    if(queue == NULL)
        return -1;
    /* 判断链式队列头部结点是否存在 */
    if(queue->front == NULL)
        return -1;
    /* 判断链式队列是否为空队列 */    
    if (queue->front->next == NULL)
        return -1;
    
    /* 出队操作 */
    q = queue->front->next;
    queue->front->next = q->next;
    free(q);
    
    if(queue->front->next == NULL)
        queue->rear = queue->front;
        
    return 0;
}

4 练习

  1. 如何使用两个队列实现一个栈

在这里插入图片描述

void push(linkqueue_t *queue_a, linkqueue_t *queue_b, data_t mydata)
{
   if (isEmptyLinkQueue(queue_a)) {
       EnLinkQueue(queue_b, mydata);
   } else {
       EnLinkQueue(queue_a, mydata);
   }
}

int pop(linkqueue_t *queue_a, linkqueue_t *queue_b, data_t *mydata)
{
   if (isEmptyLinkQueue(queue_a)) {
       if (isEmptyLinkQueue(queue_b)) {
           return -1;    /* 没有数据可以出栈 */
       }
       while(1) {
           if (GetLinkQueue(queue_b, mydata) == -1) 
               return -1;
           DeLinkQueue(queue_b);
           if (isEmptyLinkQueue(queue_b)) {
               return 0;
           }
           EnLinkQueue(queue_a, *mydata);
       }
   } else {
       while(1) {
           if (GetLinkQueue(queue_a, mydata) == -1) 
               return -1;
           DeLinkQueue(queue_a);
           if (isEmptyLinkQueue(queue_a)) {
               return 0;
           }
           EnLinkQueue(queue_b, *mydata);
       }
   }
}


int main()
{
   data_t mydata;
   linkqueue_t *queue_a;
   linkqueue_t *queue_b;
   
   queue_a = CreateLinkQueue();
   if (queue_a == NULL)
       return -1;
   
   queue_b = CreateLinkQueue();
   if (queue_b == NULL)
       return -1;    
   
   mydata = 5;
   while(mydata) {
       printf("push data : %d\n", mydata);
       push(queue_a, queue_b, mydata);        /* 数据元素的入栈先后顺序为：5 4 3 2 1 */
       mydata--;
   }
   printf("-----------%d------------\n", __LINE__);
   
   while(1) {
       if (pop(queue_a, queue_b, &mydata) == -1)    /* 数据元素的出栈先后顺序：1  2 3 4 5 */
           break;
       printf("pop data : %d\n", mydata);    
   }
}
  1. 如何使用两个栈实现一个队列

在这里插入图片描述

int DeQueue(node_t * top_a, node_t * top_b, data_t *mydata)
{
    if (top_b->next == NULL) {
        while(1) {
            if (GetLinkStack(top_a, mydata) == -1)
                break;
            PopLinkStack(top_a);
            PushLinkStack(top_b, *mydata);
        }
    } 
    
    if (top_b->next == NULL)
        return -1;
    GetLinkStack(top_b, mydata);
    PopLinkStack(top_b);
    
    return 0;
}

int EnQueue(node_t * top_a, node_t * top_b, data_t mydata)
{
    PushLinkStack(top_a, mydata);
}

int main()
{
    node_t * top_a;
    node_t * top_b;
    data_t mydata;
    
    top_a = CreateLinkStack();
    if (top_b == NULL)
        return -1;
    top_b = CreateLinkStack();
    if (top_b == NULL)
        return -1;
        
    mydata = 5;    
    while(mydata) {
        printf("%d push is %d\n", mydata--, EnQueue(top_a, top_b, mydata));
    }
    
    while(1) {
        if (-1 == DeQueue(top_a, top_b, &mydata)) 
            break;
        printf("mydata = %d\n", mydata);
    }
}
三玖诶
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现栈和队列面试题
09-03
栈和队列是数据结构中的基础概念，它们在编程中有着广泛的应用，特别是在Java面试中常常被用来测试候选人的算法和数据结构理解能力。下面我们将详细探讨这些知识点。 1. **栈的创建**： 栈是一种后进先出（LIFO）...
栈和队列数据结构的基本概念及其相关的Python实现
09-21
为了使栈和队列的使用更加便捷，Python提供了一个名为 `collections` 的模块，其中包含 `deque`（双端队列）类，它可以高效地进行两端的插入和删除操作，适用于实现栈和队列。 在实际应用中，栈常用于表达式求值、...
栈和队列的概念
stormsunshine的博客
04-14 4196
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
栈和队列基本概念与实现
LCW0102的博客
12-02 876
栈 1、概念 展示一种特殊的线性表，只允许在固定的一端进行插入元素和删除元素的操作。进行数据的插入删除的一端叫做栈顶，另一段叫做栈底，栈中的元素遵守先进后出的原则。 2、LIFO原则 栈遵守LIFO原则，Last In First Out，最后进入的最先出去，即先进后出。 3、生活中常见的栈结构 操作系统中方法的调用过程 浏览器的前进后退 编辑器的撤回操作 代码编辑器的括号匹配 算术运算的符号优先级 4、压栈 压栈就是在栈顶插入元素，也可以叫做进栈/入栈。 5、出栈 出栈就是将栈顶元素删除。 6、画图看一下
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
栈和队列的表示及实现
1+1=王的博客
11-30 786
栈和队列栈的相关概念顺序栈的表示及实现栈的抽象数据类型的类型定义顺序栈的表示顺序表的基本操作顺序栈的初始化判断栈是否为空顺序栈的入栈顺序栈的出栈链栈的表示链栈的入栈链栈的出栈队列的基本表示及操作顺序队列循环队列的初始化求循环队列的长度循环队列的入队循环队列的出队链队列链队列的类型定义链队列初始化链队列入队链队列出队 栈的相关概念 栈（stack）是一个特殊的线性表，是限定在仅在一端进行插入和删除...
栈和队列(超详细Java实现)
qq_57735833的博客
07-30 9458
可以看到,先入栈的元素要等后入栈的元素出栈后才能出栈,栈中的元素总是遵循后进先出LIFO（Last In First Out）的原则。生活中的例子:JVM : Java虚拟机Java标准库中提供的栈 可以看到，Stack继承了Vector，Vector是动态的顺序表,与ArrayList类似,不同的是,Vector是线程安全的.实现的方法 输出结果: 2. 入栈(push) 3. 出栈(pop) 4.获取栈顶元素(peek) 5.获取元素个数(getSize) 6.判断栈是否为空(isEm
02-栈和队列.zip
01-31
栈与队列.pptx可能是课程的幻灯片，详细地展示了这两个数据结构的特性、操作以及相关算法的实现。幻灯片可能包含示例代码、图解和习题。 作业.txt可能包含了一些练习题目，要求学生实践栈和队列的操作，或者解决...
zhanheduilie.rar_栈和队列
09-24
理解栈和队列的基本概念和操作对于提升编程能力至关重要，因为它们是算法和数据结构的基础。在解决复杂问题时，熟练运用栈和队列可以帮助我们设计高效、简洁的解决方案。例如，在深度优先搜索（DFS）和广度优先搜索...
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 272
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
Codeforces Round 961 (Div. 2)
2301_80105412的博客
07-24 980
Codeforces Round 961 (Div. 2) ABC
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 639
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
2766. 重新放置石块 Medium
珞米的博客
07-24 535
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 320
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1115
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1130
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
137.只出现一次的数字Ⅱ
cqjnovo的博客
07-24 451
给你一个整数数组nums，除某个元素仅出现外，其余每个元素都恰出现请你找出并返回那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法且使用常数级空间来解决此问题。399。
LeetCode977 有序数组的平方
daishabby2486的博客
07-24 1137
LeetCode977 有序数组的平方的解题记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值