两个栈实现一个队列

2013-08-18 18:59:11

两个栈实现一个队列，包括队列的初始化、销毁、入队、出队、测长、判断空否、显示队列元素等操作。

小结：

1. 用两个栈作为队列结构，一个用于入队，另一个作为出队的辅助栈，如代码中栈sEnQueue、sDeQueue为队列结构的两个成员；
2. 初始化队列,即两个栈的初始化，如代码中函数InitQueue；
3. 队列销毁，即两个栈的销毁，如代码中函数DestoryQueue；
4. 出队，若sDeQueue为空，则将sEnQueue的元素倒入sDeQueue，然后取其栈顶元素；若非空，直接取其栈顶元素；
5. 入队，即sEnQueue的入栈操作；
6. 队列测长，即两个栈的长度值之和；
7. 注意队列的显示总，两个栈的显示顺序不同，才能得到正确的显示。

---

代码（测试暂未发现错误，欢迎交流指正）：

使用的"link_stack.h"头文件：

#include <iostream>
#include <cassert>

#ifndef _LINK_STACK_H
#define _LINK_STACK_H

using namespace std;

typedef int DataType; 

typedef struct node
{
    DataType data;
    struct node *next;
}LNode,*PLNode;

typedef struct stack
{
    PLNode top;
}Stack;

//初始化栈
void InitStack(Stack &s)
{
    s.top = NULL;  //不需头结点
}

//初始化栈
void DestoryStack(Stack &s)
{
    PLNode pPre = s.top;
    PLNode pCur = pPre->next;
    while (NULL != pCur)
    {
        delete pPre;
        pPre = pCur;
        pCur = pCur->next;
    }
}

//出栈
void PushStack(Stack &s,DataType data)
{
    PLNode pNew = new LNode;
    pNew->data = data;

    pNew->next = s.top;
    s.top = pNew;
}

//出栈
DataType PopStack(Stack &s)
{
    assert(NULL != s.top);

    DataType topData = s.top->data;

    PLNode headToDelete = s.top;
    s.top = s.top->next;
    delete headToDelete;

    return topData;
}

//获取栈顶元素
DataType GetTopOfStack(Stack &s)
{
    assert(NULL != s.top);
    return ( s.top->data );
}

//获取栈中元素个数
size_t GetLengthOfStack(Stack &s)
{
    size_t lengthOfStack = 0;
    PLNode pCur = s.top;
    while (NULL != pCur)
    {
        ++lengthOfStack;
        pCur = pCur->next;
    }

    return lengthOfStack;
}

//测试栈是否为空
bool IsStackEmpty(Stack &s)
{
    return (s.top == NULL ? true : false);
}

//从栈顶到栈底显示元素
void DisplayStack(Stack &s)
{
    PLNode pCur = s.top;
    while (NULL != pCur)
    {
        cout<<pCur->data<<"	";
        pCur = pCur->next;
    }
    //cout<<endl;
}

#endif

两个栈实现的队列：

#include <iostream>
#include <cassert>
#include "link_stack.h"

using namespace std;

//用两个栈作为队列结构
typedef struct queue
{
    Stack sEnQueue;
    Stack sDeQueue;
}Queue;

//初始化队列,即两个栈的初始化
void InitQueue(Queue &q)
{
    InitStack(q.sEnQueue);
    InitStack(q.sDeQueue);
}

//队列销毁，即两个栈的销毁
void DestoryQueue(Queue &q)
{
    DestoryStack(q.sEnQueue);
    DestoryStack(q.sDeQueue);
}

//判断队列空否
bool IsQueueEmpty(Queue &q)
{
    return ( IsStackEmpty(q.sEnQueue) && IsStackEmpty(q.sDeQueue));
}

//出队
DataType DeQueue(Queue &q)
{
    assert( !IsQueueEmpty(q) );  //检查是否为空

    DataType popData = 0;

    if ( IsStackEmpty(q.sDeQueue) )
    {
        while ( !IsStackEmpty(q.sEnQueue) )
        {
            popData = PopStack(q.sEnQueue);
            PushStack(q.sDeQueue,popData);
        }
    }

    return PopStack(q.sDeQueue);
}

//入队
void EnQueue(Queue &q,DataType data)
{
    PushStack(q.sEnQueue,data);
}

//对列测长
size_t GetLengthOfQueue(Queue &q)
{
    return (GetLengthOfStack(q.sEnQueue) + GetLengthOfStack(q.sDeQueue));
}

//获取队列首元素
DataType GetHeadOfQueue(Queue &q)
{
    return ( GetTopOfStack(q.sDeQueue) );
}

//从栈顶到栈底显示栈中元素
//pSatckTop为s.top;
void DisplayReverseStack(PLNode pSatckTop)
{
    if (NULL == pSatckTop)
    {
        return;
    }

    DisplayReverseStack(pSatckTop->next);

    cout<<pSatckTop->data<<"	";
}

//按照入队顺序（先进先显示）显示队列元素
void DisplayQueue(Queue &q)
{
    //DisplayReverseStack(q.sDeQueue.top);
    DisplayStack(q.sDeQueue);
    DisplayReverseStack(q.sEnQueue.top);
    cout<<endl;
}

//队列测试
void TestQueue()
{
    Queue q;
    InitQueue(q);
    size_t command = 0;

    const size_t PUSH = 0;
    const size_t POP = 1;
    const size_t GETLENGTH = 2;
    const size_t GETHEAD = 3;
    const size_t ISEMPTY = 4;

    DataType data;

    cout<<"Please enter the command ,end with ctrl+z : "<<endl;
    while (cin>>command)
    {
        switch(command)
        {
        case(PUSH):
            {
                cout<<"Please enter z data to push : "<<endl;
                cin>>data;
                cout<<"enqueue "<<data<<endl;

                cout<<"the queue before enqueue : "<<endl;
                DisplayQueue(q);

                EnQueue(q,data);

                cout<<"the queue after enqueue : "<<endl;
                DisplayQueue(q);

                break;
            }

        case(POP):
            {
                cout<<"the queue before dequeue : "<<endl;
                DisplayQueue(q);

                DeQueue(q);

                cout<<"the queue after dequeue : "<<endl;
                DisplayQueue(q);

                break;
            }

        case(GETLENGTH):
            {
                cout<<"the length of queue is : "<<GetLengthOfQueue(q)<<endl;

                break;
            }

        case(GETHEAD):
            {
                cout<<"the top element of stack is : "<<GetHeadOfQueue(q)<<endl;

                break;
            }
        case(ISEMPTY):
            {
                cout<<"the queue is empty or not: "<<IsQueueEmpty(q)<<endl;

                break;
            }
        default:
            break;
        }
        cout<<"Please enter the command ,end with ctrl+z : "<<endl;
    }

    DestoryQueue(q); //销毁栈
}

int main()
{
    TestQueue();
    return 0;
}

测试结果：

Please enter the command ,end with ctrl+z :
2
the length of queue is : 0
Please enter the command ,end with ctrl+z :
0
Please enter z data to push :
1
enqueue 1
the queue before enqueue :

the queue after enqueue :
1
Please enter the command ,end with ctrl+z :
0
Please enter z data to push :
2
enqueue 2
the queue before enqueue :
1
the queue after enqueue :
1       2
Please enter the command ,end with ctrl+z :
0
Please enter z data to push :
3
enqueue 3
the queue before enqueue :
1       2
the queue after enqueue :
1       2       3
Please enter the command ,end with ctrl+z :
1
the queue before dequeue :
1       2       3
the queue after dequeue :
2       3
Please enter the command ,end with ctrl+z :
0
Please enter z data to push :
4
enqueue 4
the queue before enqueue :
2       3
the queue after enqueue :
2       3       4
Please enter the command ,end with ctrl+z :
0
Please enter z data to push :
5
enqueue 5
the queue before enqueue :
2       3       4
the queue after enqueue :
2       3       4       5
Please enter the command ,end with ctrl+z :
1
the queue before dequeue :
2       3       4       5
the queue after dequeue :
3       4       5
Please enter the command ,end with ctrl+z :
1
the queue before dequeue :
3       4       5
the queue after dequeue :
4       5
Please enter the command ,end with ctrl+z :
1
the queue before dequeue :
4       5
the queue after dequeue :
5
Please enter the command ,end with ctrl+z :
1
the queue before dequeue :
5
the queue after dequeue :

Please enter the command ,end with ctrl+z :
1
the queue before dequeue :

Assertion failed: !IsQueueEmpty(q), file e:visual studio 2010_projectsqueue_ma
de_by_two_stack_2013_08_17queue_made_by_two_stack_2013_08_17queue_made_by_two_
stack.cpp, line 37
请按任意键继续. . .