用两个栈实现队列

最新推荐文章于 2024-02-21 17:10:17 发布
最新推荐文章于 2024-02-21 17:10:17 发布
阅读量302 收藏
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mahao1107/article/details/47218559
版权

原理：

由于栈是先进后出的，所以，让数据先进入一个栈中，然后依次从栈顶弹出，在依次进入另一个栈中，最后，从另一个栈中弹出，并输出，这样就变为先进先出了，实现了我们的队列

实现代码

//linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef struct linklistnode {
    struct linklistnode *next;
    int item;       //自身的一些数据和其他的数据
}LinkListNode;

typedef struct linklist {
    LinkListNode header;
    int length;
}LinkList;

LinkList *LinkList_Create();
void LinkList_Destroy(LinkList *list);
void LinkList_Clear(LinkList *list);
int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);
LinkListNode *LinkList_Get(LinkList *list, int pos);
LinkListNode *LinkList_Delete(LinkList *list, int pos);

#endif //__LINKLIST_H__

//linklist.c

#include <stdlib.h>

#include "linklist.h"

LinkList *LinkList_Create()
{
    LinkList *ret = NULL;

    ret = malloc(sizeof(LinkList));

    if ( ret != NULL ) {
        ret->length      = 0;
        ret->header.next = NULL;
    }

    return ret;
}

void LinkList_Destroy(LinkList *list)
{
    free(list);
}

void LinkList_Clear(LinkList *list)
{
    if ( list != NULL ) {
        list->length      = 0;
        list->header.next = NULL;
    }
}

int LinkList_Length(LinkList *list)
{
    int ret = -1;

    if ( list != NULL ) {
        ret = list->length;
    }

    return ret;
}

int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
    int ret = list!=NULL && node!=NULL && pos>=0;

    if ( ret ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos && cur->next!=NULL; i++) {
            cur = cur->next;
        }
        node->next = cur->next;
        cur->next = node;
        list->length++;
    }

    return ret;
}

LinkListNode *LinkList_Get(LinkList *list, int pos)
{
    LinkListNode *ret = NULL;

    if ( list!=NULL && (0<=pos && pos<list->length) ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;
    }

    return ret;
}

LinkListNode *LinkList_Delete(LinkList *list, int pos)
{
    LinkListNode *ret = NULL;

    if ( list!=NULL && (0<=pos&&pos<list->length) ) {
        int i;
        LinkListNode *cur = (LinkListNode*)list;

        for (i=0; i<pos; i++)
            cur = cur->next;
        ret = cur->next;
        cur->next = ret->next;
        list->length--;
    }

    return ret;
}

//linkstack.h

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__

typedef struct linkstacknode {
    struct linkstacknode *next;
    void *item;
}LinkStackNode;

typedef void LinkStack;

LinkStack *LinkStack_Create();
void LinkStack_Destroy(LinkStack *stack);
void LinkStack_Clear(LinkStack *stack);
int LinkStack_Push(LinkStack *stack, void *item);
void *LinkStack_Pop(LinkStack *stack);
void *LinkStack_Top(LinkStack *stack);
int LinkStack_Size(LinkStack *stack);

#endif //__LINKSTACK_H__

//linkstack.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "linkstack.h"
#include "linklist.h"

LinkStack *LinkStack_Create()
{
    return LinkList_Create();
}

void LinkStack_Destroy(LinkStack *stack)
{
    LinkStack_Clear(stack);
    LinkList_Destroy(stack);
}

void LinkStack_Clear(LinkStack *stack)
{
    while ( LinkStack_Size(stack) > 0 )
        LinkStack_Pop(stack);
}

int LinkStack_Push(LinkStack *stack, void *item)
{
    LinkStackNode *node = malloc(sizeof(LinkStackNode));
    int ret = stack!=NULL && item!=NULL && node!=NULL;

    if ( ret ) {
        memset(node, 0x00, sizeof(*node));
        node->item = item;
        ret = LinkList_Insert(stack, (LinkListNode*)node, 0);
    }

    if ( !ret ) {
        free(node);
    }

    return ret;
}

void *LinkStack_Pop(LinkStack *stack)
{
    LinkStackNode *node = NULL;
    void *ret = NULL;

    node = (LinkStackNode*)LinkList_Delete(stack, 0);//返回要删除的节点，给node

    if ( node != NULL ) {
        ret = node->item;
        free(node);
    }

    return ret;
}

void *LinkStack_Top(LinkStack *stack)
{
    LinkStackNode *node= NULL;
    void *ret = NULL;

    node = (LinkStackNode*)LinkList_Get(stack, 0);

    if ( node != NULL ) {
        ret = node->item;
    }

    return ret;
}

int LinkStack_Size(LinkStack *stack)
{
    return LinkList_Length(stack);
}

//squeue.h

#ifndef __SQUEUE_H__
#define __SQUEUE_H__

#include "linkstack.h"

typedef struct squeue
{
    LinkStack *inStack;     //进数据的栈
    LinkStack *outStack;    //出数据的栈
}SQueue;

SQueue *SQueue_Create();
void SQueue_Destroy(SQueue *queue);
void SQueue_Clear(SQueue *queue);
int SQueue_Append(SQueue *queue, void *item);
void *SQueue_Retrieve(SQueue *queue);
void *SQueue_Header(SQueue *queue);
int SQueue_Length(SQueue *queue);

#endif //__SQUEUE_H__

//squeue.c

#include <stdio.h>
#include <stdlib.h>

#include "linkstack.h"
#include "squeue.h"

SQueue *SQueue_Create()
{
    SQueue *ret = malloc(sizeof(SQueue));

    if( ret!=NULL )
    {
        ret->inStack = LinkStack_Create();
        ret->outStack = LinkStack_Create();
//只要有一个栈创建失败了，那么我们就应该把我们创建的栈给销毁掉
        if( ret->inStack==NULL || ret->outStack==NULL )
        {
            LinkStack_Destroy(ret->inStack);   
            LinkStack_Destroy(ret->outStack); 
            free(ret);
            ret = NULL;
        }
    }

    return ret;
}

void SQueue_Destroy(SQueue *queue)
{
    SQueue_Clear(queue);
    free(queue);
}

void SQueue_Clear(SQueue *queue)
{
    if( queue!=NULL )
    {
        LinkStack_Clear(queue->inStack); 
        LinkStack_Clear(queue->outStack); 
    }
}

//入队
int SQueue_Append(SQueue *queue, void *item)
{
    int ret = queue!=NULL;

    if( ret )
    {
        ret = LinkStack_Push(queue->inStack, item);
    }

    return ret;
}

//出队
void *SQueue_Retrieve(SQueue *queue)
{
    void *ret = NULL;

    if( queue != NULL )
    {
        if( LinkStack_Size(queue->outStack) == 0 )  //out为空的时候
        {
            while ( LinkStack_Size(queue->inStack) > 0 )//同时in不为空,那么
            {
                LinkStack_Push(queue->outStack, LinkStack_Pop(queue->inStack)); 
                //从in里面弹出，并进入out里面 
            }
        }

        ret = LinkStack_Pop(queue->outStack); //out不为空的时候，直接让它弹出
    }
    return ret;
}

//队头
void *SQueue_Header(SQueue *queue)
{
    void *ret = NULL;

    if( queue != NULL )
    {
        if( LinkStack_Size(queue->outStack) == 0 )  //out为空的时候
        {
            while ( LinkStack_Size(queue->inStack) > 0 )//同时in不为空,那么
            {
                LinkStack_Push(queue->outStack, LinkStack_Pop(queue->inStack)); 
                //从in里面弹出，并进入out里面 
            }
        }

        ret = LinkStack_Top(queue->outStack); //out不为空的时候，直接让Top取出
    }

    return ret;
}

//求长度
int SQueue_Length(SQueue *queue)
{
    int ret = -1;

    if( queue != NULL )
    {
        ret = LinkStack_Size(queue->inStack) + LinkStack_Size(queue->outStack); 
    }

    return ret;
}

//main.c

#include <stdio.h>
#include <stdlib.h>

#include "squeue.h"

int main( void )
{
    SQueue *queue = SQueue_Create();

    int i;
    int a[5] = {11,22,33,44,55};

    for(i=0; i<5; i++)
    {
        SQueue_Append(queue, a+i); 
    }


    //SQueue_Append(queue, a); 

    while ( SQueue_Length(queue) > 0 )
    {
        printf("%d ",*(int *)SQueue_Retrieve(queue));
    }
    printf("\n");

    SQueue_Destroy(queue);

    return 0;
}

//Makefile

.PHONY : main clean

CC=gcc -g

main: main.o linklist.o linkstack.o squeue.o
    $(CC) $^ -o $@

clean:
    rm -rf *.o  main
Fireworks_light
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣 用两个栈实现队列
weixin_46415067的博客
07-10 252
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 示例： 输入： ["CQueue","appendTail","deleteHead","deleteHead"] [[],[3],[],[]] 输出：[null,null,3,-1] 解题思路 首先初始化两个栈，因为栈是后进后出的，所以我们想实现队列的先进先出，就要.
python使用两个栈实现队列
Trb601012的博客
02-04 450
因此如果想要利用两个栈来形成队列，就要将后进先出的结构特点改造成先进先出，将队列的入队和出队两个过程分开来进行处理，栈的入栈和队列的入队其实是差别不大的，只是出栈和出队的顺序是相反的，只需要想办法利用两个栈的配合来模拟实现先进先出的出队过程即可。如果想要实现以hello的顺序出栈，借助第二个栈将h重新置于栈的顶部，o置于栈的底部，有了这一思路就很容易解决这个问题了，只要将第一个栈中的元素依次出栈并放入第二个栈中，即可使单词按照hello的顺序在第二个栈中从栈顶至栈底排列。最后祝大家天天进步！
用两个栈实现队列java实现_使用两个栈实现队列
weixin_39931390的博客
03-02 170
题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。思路：用两个栈来模拟队列，一个栈作为存储，另一个栈作为交换空间。队列的push操作就直接push到第一个栈中，队列的pop操作，需要取得第一个栈低的元素，所以先把第一个栈的元素出栈，入栈到第二个队列，那么取的元素就是第二个栈的栈顶，第二个栈直接出栈即可。然后把剩下的数据在还原回去。实现代码：import ja...
用两个栈实现队列Java
qq_43692287的博客
03-25 832
栈和队列
[数据结构] 用两个栈实现队列详解
weixin_67596609的博客
03-22 3772
在数据结构中，栈和队列是较为常见的两种数据结构。。那怎么用栈去实现队列呢？此问题在面试中也是高频出现的问题。本篇文章会给出详细解释。
使用两个栈实现队列
最新发布
weixin_62988359的博客
02-21 3205
在计算机科学中，队列是一种具有先进先出（FIFO）特性的数据结构。在本篇博客中，我们将介绍如何使用两个栈来实现一个队列。这种方法的核心思想是利用栈的特性，即后进先出（LIFO），来模拟队列的先进先出特性。首先，我们需要创建一个名为MyQueuestack1和stack2。这两个栈将用于实现队列的功能。接下来，我们需要实现队列的基本操作，包括pushpoppeek和empty。首先，我们需要创建一个队列类。
java怎么用两个栈实现队列_如何使用两个栈实现队列Java
weixin_34244326的博客
03-01 201
如何使用两个栈实现队列Java发布时间：2020-09-09 23:29:12来源：脚本之家阅读：100作者：ERFishing这篇文章主要介绍了如何使用两个栈实现队列Java,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下题目用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。题解描述栈的特性是先进后出，队列的特点...
【使用两个栈实现队列】
邓富民的博客
03-01 1644
使用两个栈实现队列的功能
Leetcode—— 用两个栈实现队列
Yawn
06-18 279
1.题目 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 示例 1： 输入： [“CQueue”,“appendTail”,“deleteHead”,“deleteHead”] [[],[3],[],[]] 输出：[null,null,3,-1] 示例 2： 输入： [“CQueue”,“deleteHead”,“appendT
如何使用两个栈实现队列Java
08-25
这种实现方法虽然在pop操作时可能会有额外的时间开销（如果栈2为空，需要转移所有元素），但在某些情况下，如空间限制或特定应用场景下，使用两个栈实现队列可能比直接使用Java提供的Queue接口更具优势，因为它避免...
Java编程用两个栈实现队列代码分享
08-29
总的来说，用两个栈实现队列是一种巧妙的算法设计，它展示了如何通过调整数据结构的使用方式来适应不同的需求。通过理解这种转换，开发者可以更好地掌握数据结构的运用，并在解决问题时更加灵活。此外，这个概念还...
用两个栈实现队列1
08-03
标题 "用两个栈实现队列1" 描述的是一个编程问题，主要目标是利用两个栈来模拟一个队列的行为。队列是一种先进先出（FIFO，First In First Out）的数据结构，通常有两个主要操作：入队（在队尾添加元素）和出队（在...
剑指offer刷题记录之用两个栈实现队列
12-22
要求用两个栈{stack1，stack2}实现一个队列，也就是说我们需要使用栈的push和pop功能来构造队列的push和pop功能。 栈我们用列表表示，相应的功能使用append和pop函数实现。 队列的push功能： 使用stack1来存储元素，...
解析如何用两个栈来实现队列的方法
09-05
有时候，我们可能需要利用现有的数据结构来模拟另一种数据结构的功能，比如这里提到的用两个栈实现队列。 标题和描述中提到的方法是将两个栈（stack1 和 stack2）用于创建一个功能完备的队列。这个创新的实现方式...
goto语句的使用案例
Fire的博客
07-25 3673
案例一：//用goto语句，实现1加到n的和#include <stdio.h>int main( void ) { int n; int i =1; int sum = 0; printf("n: "); scanf("%d",&n);label: sum += i++; if(i<=n) { goto label;
清除键盘缓冲区
Fire的博客
07-18 2654
标准方法 fflush（stdin）另一种方法：scanf("%*[^\n]");读入不是换行符的字符串，不保存，返回 scanf("%*c"); 读入一个字符，不保存，返回这俩句代码的意思是用扫描集将缓冲区中的字符全部读取来实现清除缓冲区的动作。 详细解释：%*[^\n] 表示将逐个读取缓冲区中的'\n'字符之前的其它字符%后面的*表示将读取的这些字符丢弃遇到'\n'字符时
线性表实例
Fire的博客
08-02 2598
线性表的本质：由0个或多个数据元素组成的集合 数据元素之间是顺序的 数据元素个数是有限的 数据元素的类型必须是相同的 专业的定义：线性表是具有相同类型的n(n>=0)个数据元素的有限序列（a0，a1，a2，...an） ai是表项，n是长度 性质：a0为线性表中的第一个元素，只有一个后继 an为线性表中的最后一个元素，只有一个前驱 除了a0和an之外的其他元素ai，既有一个直接前驱，也有一个直接后继
回溯法经典案例----N皇后
Fire的博客
07-23 1963
在一个N*N的棋盘上放置N个皇后，且使得每两个之间不能互相攻击，也就是使得每两个不在同一行，同一列和同一斜角线上。 下面N取8； //八皇后=====92种#include <stdio.h>#define N 8char board[N+2][N+2];typedef struct pos { int ios; int jos; }Pos_t;Pos_t pos[3] = {
如何用两个栈实现队列
08-18
可以使用两个栈来模拟队列的操作。一个栈用于入队操作，另一个栈用于出队操作。下面是使用两个栈实现队列的步骤： 1. 入队操作（enqueue）： - 将元素依次压入入队栈（Stack A）。 2. 出队操作（dequeue）： - 如果出队栈（Stack B）为空，将入队栈中的元素逐个弹出并压入出队栈，直到入队栈为空。 - 弹出出队栈的栈顶元素，即为队列的队首元素。 这样，通过两个栈的协作，可以实现队列的先进先出特性。当需要进行出队操作时，如果出队栈不为空，则直接弹出栈顶元素；如果出队栈为空，则将入队栈中的元素转移到出队栈中，再弹出栈顶元素。 需要注意的是，在进行出队操作之前，必须确保出队栈中没有元素，否则会影响到队列的顺序。另外，入队和出队操作的时间复杂度为O(1)，均摊时间复杂度较低。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值