2. 程式人生 > >通過兩個佇列實現一個棧（C語言）

通過兩個佇列實現一個棧（C語言）

阿新 • • 發佈：2019-01-02

stackBy2Queue.h檔案

#pragma once

#define max_size 1000

typedef char DataType;

typedef struct Queue
{
    DataType data[max_size];
    int head;
    int tail;
    //佇列中有效元素個數
    int size;
}Queue;

typedef struct Stack
{
    Queue queue1;
    Queue queue2;
    //棧中有效元素個數
    int size;
}Stack;
//初始化函式
void
 
 StackInit(Stack *stack);
//銷燬函式
void StackDestroy(Stack *stack);
//入棧操作函式
void StackPush(Stack *stack,DataType value);
//出棧操作函式
void StackPop(Stack *stack);
//取棧頂元素函式
int StackGetTop(Stack *stack,DataType *value);

stackBy2Queue.c檔案

#include<stdio.h>
#include"stackBy2Queue.h"

#define Test_Header printf("\n==========%s==========\n",__FUNCTION__);
 


//佇列初始化函式
void QueueInit(Queue *queue)
{
    if(queue == NULL)
    {
        //非法輸入
        return;
    }
    queue->head = 0;
    queue->tail = 0;
    queue->size = 0;
}
//佇列銷燬函式
void QueueDestroy(Queue *queue)
{
    if(queue == NULL)
    {
        //非法輸入
        return;
    }
    queue->head = 0
 
;
    queue->tail = 0;
    queue->size = 0;
}
//入佇列操作函式
void QueuePush(Queue *queue,DataType value)
{
    if(queue == NULL)
    {
        //非法輸入
        return;
    }
    if(queue->size >= max_size)
    {
        //佇列滿了
        return;
    }
    queue->data[queue->tail++] = value;
    queue->size++;
    if(queue->tail > max_size)
    {
        //如果tail走到了佇列的尾部
        queue->tail = 0;
    }
}
//出佇列操作函式
void QueuePop(Queue *queue)
{
    if(queue == NULL)
    {
        //非法輸入
        return;
    }
    if(queue->size == 0)
    {
        //空佇列
        return;
    }
    if(queue->head >= max_size)
    {
        //如果head走到了佇列的最後一個元素
        //呢出佇列以後繼續回到佇列一開始的地方
        //就相當於是將最後一個元素出對佇列
        queue->head = 0;
    }
    //否則直接將head往後移動一步
    queue->head++;
    //將對列元素個數-1
    queue->size--;
    if(queue->size == 0)
    {
        queue->head = 0;
        queue->tail = 0;
    }
}
//取隊首元素函式
int QueueGetTop(Queue *queue,DataType *value)
{
    if(queue == NULL)
    {
        //非法輸入
        return 0; 
    }
    if(queue->size == 0)
    {
        //空佇列
        return 0;
    }
    *value = queue->data[queue->head];
    return 1;
}
void Print(Queue *queue)
{
    if(queue == NULL)
    {
        //非法輸入
        return;
    }
    if(queue->size == 0)
    {
        return;
    }
    if(queue->head < queue->tail)
    {
        int i = queue->head;
        for(;i < queue->tail;i++)
        {
            printf("%c ",queue->data[i]);
        }
    }
    else
    {
        int i = queue->head;
        while(queue->head < max_size)
        {
            printf("%c ",queue->data[queue->head]);
            queue->head++;
        }
        queue->head = 0;
        for(;i < queue->tail;i++)
        {
            printf("%c ",queue->data[i]);
        }
    }
    printf("\n\n");
}

以下為通過兩個佇列實現一個棧的入棧，出棧和取棧頂元素的操作

//棧初始化函式
void StackInit(Stack *stack)
{
    if(stack == NULL)
    {
        //非法輸入
        return;
    }
    QueueInit(&stack->queue1);
    QueueInit(&stack->queue2);
    stack->size = 0;
}
//棧銷燬函式
void StackDestroy(Stack *stack)
{
    if(stack == NULL)
    {
        //非法輸入
        return;
    }
    QueueDestroy(&stack->queue1);
    QueueDestroy(&stack->queue2);
    stack->size = 0;
}

入棧操作思路：
情況1：兩個佇列都為空那就隨便哪一個佇列將元素入佇列即可，也就相當於入棧操作，如下圖（虛線表示模擬一個棧）
這裡寫圖片描述
情況2：其中一個佇列有元素，一個佇列沒有元素，則將元素插入到有元素的佇列中，如下圖，此時待入棧的c和d要插入到佇列1中
這裡寫圖片描述

//入棧操作函式
void StackPush(Stack *stack,DataType value)
{
    if(stack == NULL)
    {
        //非法輸入
        return;
    }
    //每次入棧時找到佇列不為空的那一個佇列入佇列（相當於入棧）
    //或者兩個棧都為空時隨便入哪一個佇列都行
    if(stack->queue1.size != 0)
    {
        //佇列1不為空
        QueuePush(&stack->queue1,value);
    }
    else
    {
        //佇列2不為空或者兩個佇列都為空
       QueuePush(&stack->queue2,value);
    }
    //每入棧一個元素將棧的有效元素個數+1
    stack->size++;
}

出棧操作思路：如圖所示，此時佇列1 當中有元素
這裡寫圖片描述
但是由於佇列只能從隊首將元素出佇列，而我們入棧的元素順序是a b c d,所以根據棧後進先出的特點，此時出棧的元素應該是d,所以我們要將佇列1 中的元素移動到一個空佇列中也就是佇列2，但是我們必須留下佇列1中的隊尾的最後一個元素，只剩下最後一個元素時，將這個元素出佇列，就剛好模擬了棧的出棧操作。
這裡寫圖片描述

//出棧操作函式
void StackPop(Stack *stack)
{
    if(stack == NULL)
     {
         //非法輸入
         return;
     }
    if(stack->size == 0)
    {
        //空棧
        return;
    }
    Queue *from = NULL;
    Queue *to = NULL;
    //將from指向有元素的佇列，to指向沒有元素的佇列
    if(stack->queue1.size != 0)
    {
        from = &stack->queue1;
        to = &stack->queue2;
    }
    else
    {
        from = &stack->queue2;
        to = &stack->queue1;
    }
    //將from中的元素到騰到to中（但是from中必須要留下最後一個元素用於最後的出佇列也就是出棧操作）
    while(from->size != 1)
    {
        DataType top;
        //取到from佇列隊首元素的值
        QueueGetTop(from,&top);
        //然後對from佇列進行一次出棧操作
        QueuePop(from);
        //將從from佇列取到的隊首元素值插入到to佇列中
        QueuePush(to,top);
    }
    //迴圈結束
    //此時from中就剩下最後一個元素將其出佇列也就完成出棧操作
    QueuePop(from);
    //每出棧一次就將棧的有效元素個數-1
    stack->size--;
}

取棧頂元素思路：取棧頂元素操作和出棧操作類似，唯一不同的就是，當我們將元素移動到只剩下最後一個元素的時候，我們需要的是讀取到該元素的值（取隊首元素操作就行了），而這個元素依舊存在於該棧中，所以為了確保棧的元素不被破壞，讀取完元素值以後我們依舊要把該元素移動到另外那個佇列中去。

//取棧頂元素函式
int StackGetTop(Stack *stack,DataType *value)
{
    if(stack == NULL || value == NULL)
    {
        //非法輸入
        return 0;
    }
    if(stack->size == 0)
    {
        //空棧
        return 0;
    }
    Queue *from = NULL;
    Queue *to = NULL;
    //將from指向有元素的佇列，to指向沒有元素的佇列
    if(stack->queue1.size != 0)
    {
        from = &stack->queue1;
        to = &stack->queue2;
    }
    else
    {
        from = &stack->queue2;
        to = &stack->queue1;
    }
    //將from中的元素到騰到to中（但是from中必須要留下最後一個元素用於最後的取隊首元素操作也就是取棧頂元素操作）
    while(from->size != 1)
    {
        DataType top;
        //取到from佇列隊首元素的值
        QueueGetTop(from,&top);
        //然後對from佇列進行一次出棧操作
        QueuePop(from);
        //將從from佇列取到的隊首元素值插入到to佇列中
        QueuePush(to,top);
    }
    //迴圈結束
    //此時from中就剩下最後一個元素
    //對from佇列取隊首元素操作（也就是取棧頂元素）
    int ret = QueueGetTop(from,value);
    //當我們取到棧頂元素之後，在將該元素從from隊列出佇列
    QueuePop(from);
    //並且將該元素入to佇列
    //否則棧就被破壞了
    QueuePush(to,*value);
    return ret;
}
//列印函式便於觀察測試結果(思路不做解釋)
void PrintStackElem(Stack *stack,const char *msg)
{
    printf("[%s]\n",msg);
    if(stack == NULL)
    {
        //非法輸入
        return;
    }
    if(stack->size == 0)
    {
        //空棧
        return;
    }
    Queue *print = NULL;
    if(stack->queue1.size == 0)
    {
        print = &stack->queue2;
    }
    else
    {
        print = &stack->queue1;
    }
    Print(print);
}

//以下為測試函式
void TestStackBy2Queue()
{
    Test_Header;
    Stack stack;
    //初始化
    StackInit(&stack);
    //入棧函式測試
    StackPush(&stack,'a');
    StackPush(&stack,'b');
    StackPush(&stack,'c');
    StackPush(&stack,'d');
    PrintStackElem(&stack,"入棧4個元素expected：a b c d");
    //取棧頂元素測試
    DataType top;
    int ret = StackGetTop(&stack,&top);
    printf("expected ret = 1,actual ret = %d\n",ret);
    printf("expected top = d,actual top = %c\n",top);
    //出棧函式測試
    StackPop(&stack);
    StackPop(&stack);
    PrintStackElem(&stack,"出棧兩個元素之後expected: a b");
    //取棧頂元素函式測試2  
    ret = StackGetTop(&stack,&top);
    printf("expected ret = 1,actual ret = %d\n",ret);
    printf("expected top = b,actual top = %c\n",top);

    StackPop(&stack);
    StackPop(&stack);
    PrintStackElem(&stack,"將剩下的兩個元素出棧之後expected:");
    //取棧頂元素函式測試3
    ret = StackGetTop(&stack,&top);
    printf("expected ret = 0,actual ret = %d\n",ret);
    //銷燬棧
    StackDestroy(&stack);
}
//主函式呼叫測試函式
int main()
{
    TestStackBy2Queue();
    return 0;
}

測試結果如下圖：
這裡寫圖片描述

相關推薦

通過兩個佇列實現一個棧（C語言）

stackBy2Queue.h檔案 #pragma once #define max_size 1000 typedef char DataType; typedef struct Queue { DataType data[max_size

兩個佇列實現一個棧（C語言）

本題的思路是先建立queue1和queue2，入棧時直接向queue1裡入佇列，出棧時需要先從queue1中出佇列的同時把數依次進入queue2，直到queue1中到最後一個數為止，然後將queue1中的數出佇列，再將queue2中的數倒回queue1，這樣就實

詳解兩個佇列實現一個棧（python實現——經典面試題）

1、任務詳解        使用兩個佇列資料結構實現一個棧，要求實現棧的出棧和進棧操作。 2、解題思路        push()操作：        為了保證先進

兩個棧實現一個佇列以及兩個佇列實現一個棧（Java）

兩個棧實現一個佇列 import java.util.Stack; public class Demo07 { Stack<Integer> stack1 = new Sta

佇列實現棧，兩個佇列實現一個棧方法詳解（含實現程式碼）

本節介紹一下如何用兩個佇列實現棧。 棧的主要操作就是入棧和出棧，其特點就是後進先出。我們先將兩個佇列分別定義為 queue1 與 queue2。 方案 1 入棧和出棧，都在 queue1 中完成，而 queue2 作為中轉空間。 入棧：直接入 queue1 即可。 出棧：把 queue1 中除最後一

棧和佇列面試題（三）---用兩個佇列實現一個棧

一：queue是一種”先進先出”的資料結構，他在對尾插入元素，在隊頭刪除元素，他既可以取到自己的隊頭元素，也可以取到自己的隊尾元素； stack是一種”先進後出”的資料結構，他對元素的插入和

python ——兩個佇列實現一個棧&兩個棧實現一個佇列

1、兩個佇列實現一個棧 進棧：元素入佇列A 出棧：判斷如果佇列A只有一個元素，則直接出隊。否則，把隊A中的元素出隊併入隊B，直到隊A中只有一個元素，再直接出隊。為了下一次繼續操作，互換隊A和隊B。 python實現如下： class StackWithTwoQueues(object

兩個棧實現一個佇列 兩個佇列實現一個棧

棧和佇列實現的程式碼在連結中的部落格https://blog.csdn.net/Damn_Yang/article/details/83928852 兩個棧實現一個佇列  思路：            入隊時，直接壓入

05、兩個棧實現一個佇列，兩個佇列實現一個棧

題目描述： 1. 用兩個棧來實現一個佇列，完成佇列的Push和Pop操作。 佇列中的元素為int型別。 2. 用兩個佇列來實現一個棧，完成棧的Push和Pop操作。 佇列中的元素為int型別。 解題思路： 1. 入隊時，直接壓入stack1中；出隊時，判斷stack2是

兩個棧實現一個佇列，兩個佇列實現一個棧

1、兩個棧實現一個佇列            入隊時，直接壓入stack1中。            出隊時，判斷stack2是否為空，如果stack2為空，則將stack1中的元素倒入stack2中，否則直接彈出stack2中的元素。 //入隊操作 void EnQu

【面試題】兩個佇列實現一個棧

題目：用佇列來實現棧。 用兩個佇列來回倒騰基本就可以了，假設有兩個佇列A、B，初始都為空，將元素放入佇列A中，如果佇列B不為空，將B中的元素全部取出放入A中，這樣B就為空隊列了，然後下次加入元素就加入

兩個佇列實現一個棧 + 兩個棧實現一個佇列 Java

面試中常出現讓你手寫兩個佇列實現一個棧，兩個棧實現一個佇列的問題，很是頭疼！今天就仔細將我分析，思考過的Java程式碼給大家分享一下：（一）兩個佇列實現一個棧： 兩個佇列新增元素，哪個佇列為空，由於

兩個佇列實現一個棧結構

# 思路：兩個佇列，佇列1只負責壓棧，佇列2只負責出棧 class Two_queue(object): def __init__(self): self._oneli=[] self._twoli=[] def entrance(self,i

C/C++面試題—使用STL兩個佇列實現一個棧

題目介紹 使用STL中的兩個佇列實現一個棧，實現棧的top、pop、push、clear等操作。 思路分析 思路和使用2個棧實現一個佇列是相通的，用一個佇列queue1容器用來 壓棧，出棧的時候判斷queue1.size()是否大於1，大於1的話隊尾元

使用兩個佇列實現一個棧，使用兩個棧實現一個佇列！

轉自：http://blog.csdn.net/zgh1988/article/details/6988904 時間：小師妹請客之後，2013/6/16 1、這裡所說的都是STL中的queue，stack      其中queue的特點是先進先出，它所具有的函式有：

用兩個棧實現一個佇列&用兩個佇列實現一個棧

做題之前，我們先來回顧一下“棧和佇列的相同點以及不同點”，便於做題時的應用！1.區別與聯絡相同點：（1）棧和佇列都是控制訪問點的線性表；              （2）棧和佇列都是允許在端點處進行資料的插入和刪除的資料結構；不同點：（1）棧遵循“後進先出（LIFO）”的原則

用兩個佇列實現一個棧

題目： 說明如何用兩個佇列來實現一個棧，並分析有關棧操作的執行時間。 解法： 1.有兩個佇列q1和q2，先往q1內插入a，b，c，這做的都是棧的push操作。 2.現在要做pop操作，即要得到c，這時可以將q1中的a,b兩個元素全部dequeue並存入q2中，這時q2中元素

leetcode解題之225 # Implement Stack using Queuest Java版 (用兩個佇列實現一個棧）

225. Implement Stack using Queues Implement the following operations of a stack using queues. pu

兩個棧實現一個佇列/兩個佇列實現一個棧

1兩個棧實現一個佇列 1.原理分析： 佇列的主要操作有兩個：入隊操作和出隊操作，出隊時從隊頭出，入隊是從隊尾插入，入隊的操作和入棧的操作類似，而最關鍵的問題是出隊操作，要出佇列的是佇列的第一個元素，而出棧的是棧的棧頂元素，所以我們可以這樣：        假設兩個棧A和棧B

用兩個棧實現佇列和用兩個佇列實現一個棧

題目：用兩個棧實現一個佇列。佇列的生命如下，請實現它的兩個函式appendTail和deleteHead，分別完成在佇列尾部插入結點和在佇列頭部刪除結點的功能。 template <typename T>class CQueue { public: 　　C