栈和队列

最新推荐文章于 2024-10-20 09:49:14 发布
最新推荐文章于 2024-10-20 09:49:14 发布
阅读量87 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Lune-Qiu/p/9001085.html
版权

栈：FILO 其实就是一端增加和一端删除的链表    一般我们对头进行增加和删除

几个必要函数：1.Init   2.Push 3.Pop 4.Clear  5.Destroy  6.GetTop 7.GetCount 8.IsEmpty 

怎样销毁栈？ 销毁后不能进行Push 和Pop 

1.设置标志，执行销毁函数后，将标志置为false，Push 和Pop则不能执行

2.将Node结构体放入另一个结构体栈中，这样销毁了栈的地址

栈的代码：

#include "stdio.h"
#include "stdlib.h"
typedef struct node1
{
    int val;
    struct node1* next;
}Node;
typedef struct node2
{
    Node* pHead;
    int len;
}Stack;
Stack* s_Init()
{
    Stack *pTop = (Stack*)malloc(sizeof(Stack));
    pTop->pHead = NULL;
    pTop->len = 0;
    return pTop;
}
void s_Push(Stack* mystack,int data)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return ;
    }
    Node* tmp = (Node*)malloc(sizeof(Node));
    tmp->val = data;
    tmp->next = mystack->pHead;
    mystack->pHead = tmp;
    mystack->len++;
}
int s_Pop(Stack* mystack)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return -1;
    }
    if(mystack->len == 0)
    {
        printf("Stack is NULL\n");
        return -1;
    }
    Node * del = mystack->pHead;
    mystack->pHead = mystack->pHead->next;
    int data = del->val;
    free(del);
    del = NULL;
    mystack->len--;
    
    return data;
}
void s_Clear(Stack* mystack)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return;
    }
    while(mystack->len != 0)
        s_Pop(mystack);
}
int  s_IsEmpty(Stack * mystack)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return -1;
    }
    return mystack->len == 0 ? 1 : 0;
}
void s_Destroy(Stack** mystack)
{
    s_Clear(*mystack);
    free(*mystack);
    *mystack = 0;
}
int s_GetTop(Stack* mystack)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return -1;
    }
    return mystack->pHead->val;
}
int s_GetCount(Stack * mystack)
{
    if(mystack == NULL)
    {    
        printf("Stack not exit\n");
        return -1;
    }
    return mystack->len;
}
Stack

栈的应用：

1.斐波那契数列  黄金分割序列  最美序列

两种方法：一种：递归，一种用三个数

int Func(int n)
{
    if(n == 1|| n == 2)
        return 1;
    return Func(n-1)+Func(n-2);
}
int Fbnci(int n)
{
    int f1 = 1;
    int f2 = 1;
    int f3 = 2;
    int num = 3;
    while(num < n)
    {
        f1 = f2;
        f2 = f3;
        f3 = f1+f2;
        num++;
    }
    return f3;
}
Fibonacci

2.四则运算

中缀表达式

后缀表达式（逆波兰表示法）

2个数的加法运算计算机实现：先^再&（得到进位的值）将值左移一位再与^所得值相加（重复操作直到&所得值为0）

中缀->后缀：借助辅助栈，遇到数字或字符直接打印，遇到符号与栈顶元素优先级比较，符号优先级高，则直接入栈。若当前符号优先级低，则依次出栈,直到栈顶元素比当前元素优先级低为止。

遇到“（ ”无条件入栈，遇到“ ）”将栈内元素依次出栈，知道出到左括号为止。

中缀->后缀：所有中缀表达式括起来，将符号拿到所在符号后面

后缀->前缀：遇到数字或字符直接入栈，遇到符号将栈顶元素后一个与栈顶构成表达式。

队列：FIFO 尾添加，头删除

循环队列：数组

#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int val;
    struct node* next;
}Node;
typedef struct que
{
    Node* pHead;
    Node* pEnd;
    int len;
}Queue;
Queue* Init()
{
    Queue* myqueue =(Queue*) malloc(sizeof(Queue));
    myqueue->pHead = NULL;
    myqueue->pEnd = NULL;
    myqueue->len = 0;
    return myqueue;
}
void Push(Queue* myqueue,int data)
{
    Node* ptmp = (Node*)malloc(sizeof(Node));
    ptmp->val = data;
    ptmp->next = NULL;
    if(myqueue->pEnd == NULL)
    {
        myqueue->pEnd = ptmp;
        myqueue->pHead = ptmp;
    }
    else        
    {
        myqueue->pEnd->next = ptmp;
        myqueue->pEnd = ptmp;
    }
    myqueue->len++;
}
int Pop(Queue* myqueue)
{
    Node* del = myqueue->pHead;
    myqueue->pHead = myqueue->pHead->next;
    int data = del->val;
    free(del);
    del = NULL;
    myqueue->len--;
    if(myqueue->len == 0)
        myqueue->pEnd = NULL;
    return data;
}
int IsEmpty(Queue* myqueue)
{
    if(myqueue == NULL) return -1;
    return myqueue->len== 0 ? 1:0;
}
Queue

两个栈模拟队列：向栈1压入元素，要弹出时将栈1元素全部弹出到栈2，从栈2取得元素，之后只要栈2不为空则从栈2取元素，为空时，再将栈1元素全部弹到栈2

#include "stdio.h"
#include "stdlib.h"
typedef struct node1
{
    int val;
    struct node1* next;
}Node;
typedef struct node2
{
    Node* pHead;
    int len;
}Stack;
typedef struct node3
{
    Stack* s1;
    Stack* s2;
    int nCount;
}Queue;
Stack* s_Init()
{
    Stack *pTop = (Stack*)malloc(sizeof(Stack));
    pTop->pHead = NULL;
    pTop->len = 0;
    return pTop;
}
void s_Push(Stack* mystack,int data)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return ;
    }
    Node* tmp = (Node*)malloc(sizeof(Node));
    tmp->val = data;
    tmp->next = mystack->pHead;
    mystack->pHead = tmp;
    mystack->len++;
}
int s_Pop(Stack* mystack)
{
    if(mystack == NULL)
    {
        printf("Stack not exit\n");
        return -1;
    }
    if(mystack->len == 0)
    {
        printf("Stack is NULL\n");
        return -1;
    }
    Node * del = mystack->pHead;
    mystack->pHead = mystack->pHead->next;
    int data = del->val;
    free(del);
    del = NULL;
    mystack->len--;

    return data;
}
Queue*  q_Init()
{
    Queue* myqueue = (Queue*)malloc(sizeof(Queue));
    myqueue->s1 = s_Init();
    myqueue->s2 = s_Init();
    myqueue->nCount = 0;
    return myqueue;
}
void q_Push(Queue* myqueue,int data)
{
    if(myqueue == NULL)
        printf("Queue not exit\n");
    s_Push(myqueue->s1,data);
    myqueue->nCount++;
}
int q_Pop(Queue* myqueue)
{
    if(myqueue == NULL)
    {
        printf("Queue not exit\n");
        return -1;
    }
    if(myqueue->s2->len == 0)
    {
        while(myqueue->s1->len != 0)
            s_Push(myqueue->s2,s_Pop(myqueue->s1));
    }
    return s_Pop(myqueue->s2);
}
StackToQueue

两个队列模拟栈：向队列中压入元素，当要弹出的时候，只留下最后一个，其余全部转到另一个队列中，再想非空队列中压入元素，弹出时转到另一个队列

#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int val;
    struct node* next;
}Node;
typedef struct que
{
    Node* pHead;
    Node* pEnd;
    int len;
}Queue;
typedef struct sta
{
    Queue* q1;
    Queue* q2;
    int nCount;
}Stack;
Queue* Init()
{
    Queue* myqueue =(Queue*) malloc(sizeof(Queue));
    myqueue->pHead = NULL;
    myqueue->pEnd = NULL;
    myqueue->len = 0;
    return myqueue;
}
void Push(Queue* myqueue,int data)
{
    Node* ptmp = (Node*)malloc(sizeof(Node));
    ptmp->val = data;
    ptmp->next = NULL;
    if(myqueue->pEnd == NULL)
    {
        myqueue->pEnd = ptmp;
        myqueue->pHead = ptmp;
    }
    else
    {
        myqueue->pEnd->next = ptmp;
        myqueue->pEnd = ptmp;
    }
    myqueue->len++;
}
int Pop(Queue* myqueue)
{
    Node* del = myqueue->pHead;
    myqueue->pHead = myqueue->pHead->next;
    int data = del->val;
    free(del);
    del = NULL;
    myqueue->len--;
    if(myqueue->len == 0)
        myqueue->pEnd = NULL;
    return data;
}
Stack* s_Init()
{
    Stack* mystack = (Stack*)malloc(sizeof(Stack));
    mystack->q1 = Init();
    mystack->q2 = Init();
    mystack->nCount = 0;
    return mystack;
}
void s_Push(Stack* mystack,int data)
{
    if(mystack->q1->len != 0)
        Push(mystack->q1,data);
    else
        Push(mystack->q2,data);
    mystack->nCount++;
}
int s_Pop(Stack* mystack)
{
    if(mystack->q1->len != 0)
    {
        while(mystack->q1->len != 1)
            Push(mystack->q2,Pop(mystack->q1));
        return Pop(mystack->q1);
    }
    else
    {
        while(mystack->q2->len != 1)
            Push(mystack->q1,Pop(mystack->q2));
        return Pop(mystack->q2);
    }

}
QueueToStack

 

转载于:https://www.cnblogs.com/Lune-Qiu/p/9001085.html

diechi0288
关注
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
2021-07-27关于c语言递归的简单理解
byoib的博客
07-27 156
递归算法是编程语言中很难回避掉的一个算法，因为凡是能用循环实现的必定能用递归实现。先来个简单的递归：求斐波那契数列的第n个值（斐波那契数列：第一个和第二个都是1，第三个开始 a（n）=a（n-2）+a（n-1））废话不多说上代码： #include<stdio.h> int func(int n) { if(n==1||n==2) return 1; else return func(n-1)+func(n-2);//实现递归； } int main() { printf("%d
递归算法详解
qq_36637957的博客
12-04 1682
递归——看这篇就够了 引子 我怀着无比激动的心情写下这篇文章，因为我它介绍是一种无比优雅的问题解决方案——递归 相信很多同学在学习递归的时候都会有这样一个疑惑，这个东西究竟是如何自己调用自己的，大佬写几行代码就实现了复杂的功能。今天我们就来好好讨论这个优雅的递归。 一、定义 在数学与计算机科学中，递归(Recursion)是指在函数的定义中使用函数自身的方法。实际上，递归，顾名思义，其包含了两个意思：递 和 归，这正是递归思想的精华所在。 用人话来说就是函数调用自己。 二、递归的三大要素 明确这个.
数据结构与算法 — 递归算法(recursion)
我会二进制
08-10 671
递归的定义 在定义一个过程或者函数时出现调用本过程或函数的成分成为递归。简单的来说就是自己调用自己。就像是老和尚的故事一样。（从前有座山，山里有座庙，庙里有个老和尚再给小和尚讲故事，讲的是从前有座山…） 调用条件 一般来说，能够用递归来解决问题应该满足三个条件： 1.需要解决的问题可以转化为一个或者多个子问题来求解，并且这些子问题的求解方式都与原问题相同，只是数量不同。 2.递归调用的次数必须是有限的。 3.必须有结束递归的条件来终止递归。 例题 【例1】以下是求n！的递归函数。 int fun(int
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 25万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
【数据结构】栈和队列
小羊的博客
07-12 2664
栈超超超详解
C语言-栈和队列
m0_73605503的博客
07-22 1341
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2253
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
栈和队列的转化
xiaobai230811的博客
12-17 1259
栈与队列的相互转换栈和队列是两种基本的数据结构，它们在许多算法和程序中都有应用。虽然栈和队列在概念上是完全不同的，但是我们可以使用两个栈来实现一个队列，或者使用两个队列来实现一个栈。这种转换在某些情况下可能非常有用，例如，当我们的编程环境只提供了栈或队列的实现，但我们需要使用另一种数据结构时。在这篇博客中，我们将详细介绍如何使用两个栈来实现一个队列，以及如何使用两个队列来实现一个栈。我们将提供详细的代码示例，并解释每个函数的工作原理。提示：以下是本篇文章正文内容，下面案例可供参考。
JavaScript栈和队列
qq_44741577的博客
01-31 990
栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。**栈的特点是：**先进后出，或者说是后进先出，从栈顶放入元素的操作叫入栈，取出元素叫出栈。栈的受限性体现在只允许在栈顶插入和删除，因此出栈和入栈都是在栈顶。
栈和队列的概念
stormsunshine的博客
04-14 4279
文章目录栈、队列和双端队列栈队列双端队列Java 中的栈、队列和双端队列单调栈和单调队列二叉堆和优先队列二叉堆优先队列 栈、队列和双端队列 栈和队列是常见的数据结构。栈的特点是后进先出，添加元素、删除元素和查看元素都在栈顶操作。队列的特点是先进先出，添加元素在队尾操作，删除元素和查看元素在队首操作。 双端队列比栈和队列更加灵活，可以在双端队列的两端添加元素、删除元素和查看元素。 栈、队列和双端队列都满足每次添加元素、删除元素和查看元素的时间复杂度是 O(1)O(1)O(1)。 栈、队列和双端队列都可以基于数
C语言中栈和队列实现表达式求值的实例
08-29
C语言中栈和队列实现表达式求值的实例 栈和队列是数据结构中两个非常重要的概念，它们在计算机科学和编程语言中有着广泛的应用。栈和队列可以用来实现表达式求值，下面我们将通过C语言来实现栈和队列实现表达式求值...
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
查找（线性/顺序、二分/折半、分块/索引、哈希）
Teriri_的博客
10-18 852
查找的平均查找长度（Average Search Length，简称 ASL）是衡量查找效率的一个重要指标，表示在查找表中查找元素时，平均需要检查的元素个数。它与查找方法、查找表的结构以及查找成功或失败的概率等因素有关。根据不同的查找方法，平均查找长度的计算方式会有所不同，下面介绍线性查找、二分查找和哈希查找的平均查找长度的计算方法。
Leetcode 1168. 水资源分配优化
m0_51437455的博客
10-14 499
对于每个房子 i，我们有两种可选的供水方案：一种是直接在房子内建造水井，成本为 wells[i – 1] （注意 -1 ，因为 索引从0开始 ）；另一种是从另一口井铺设管道引水，数组 pipes 给出了在房子间铺设管道的成本，其中每个 pipes[j] = [house1_j, house2_j, cost_j] 代表用管道将 house1_j 和 house2_j连接在一起的成本。第二步，使用Prim算法模板或者Kruskal算法模板解除最小生成树的权值和（详情可以看下代码的注释）
笔试强训10.17
2301_79761329的博客
10-17 716
用双层循环会超时，所以改用动态规划的思想。（核心是通过一次遍历找出符合条件的最大值和最小值，一次循环保证卖一定在买后面）。//法四：Manacher算法。//法三：hash+二分。
【LeetCode热题100】分治-归并
最新发布
qq_48460693的博客
10-20 256
分治-排序
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值