栈和队列

栈和队列

栈

stack.hpp

//链栈

#include <iostream>
using namespace std;

typedef int elementType;

enum status { OK = 1, ERROR = 0 };

struct stackNode
{
    elementType elem;

    struct stackNode *under;
};
// 栈顶指针
typedef struct stackNode *LinkStack;

//----------------------------------------初始化----------------------------------------//
status InitStack(LinkStack &topNode)
{
    //如果我们的编译器是支持nullptr的话，那么我们应该直接使用nullptr来替代NULL的宏定义。正常使用过程中他们是完全等价的。
    topNode = nullptr;
    return OK;
}

//----------------------------------------入栈----------------------------------------//
status Push(LinkStack &topNode, elementType newElem)
{
    stackNode *new_TopNode = new stackNode;

    new_TopNode->elem = newElem;

    new_TopNode->under = topNode;

    topNode = new_TopNode;

    return OK;
}

//----------------------------------------出栈----------------------------------------//
status Pop(LinkStack &topNode, elementType &popElem)
{
    if(topNode == nullptr)
        return ERROR;
    
    stackNode *will_DeleteNode = topNode;

    topNode = topNode->under;

    popElem = will_DeleteNode->elem;

    delete will_DeleteNode;
}

//----------------------------------------取栈顶元素----------------------------------------//
elementType GetTop(LinkStack &topNode)
{
    if(topNode != nullptr)
        return topNode->elem;
}

//----------------------------------------遍历----------------------------------------//
status StackTraverse(LinkStack &topNode)
{
    stackNode *currentNode = topNode;

    cout << "----- 当前栈中元素自顶向下为 -----" << endl;
    while(currentNode != nullptr)
    {
        cout << currentNode->elem << " ";   
        currentNode = currentNode->under;
    }

    cout << endl;
}

stack_Test.cpp

#include <iostream>
#include "stack.hpp"

using namespace std;

int main()
{
    cout << "## 链栈测试 ##" << endl;

    LinkStack testStack;

    InitStack(testStack);

    cout << "请输入数据 : " << endl;
    for(int i=0;;i++)
    {
        
        elementType elem;
        cin >> elem;

        if(elem == 0)
            break;

        Push(testStack, elem);
    }

    StackTraverse(testStack);

    cout << "1:进栈" << endl;
    cout << "2:出栈" << endl;
    cout << "3:取栈顶元素" << endl;

    while(true)
    {
        int elem;

        int choice;
        cin >> choice;

        switch (choice)
        {
            case 1:
            {
                cout << "请输入入栈元素 : ";
                cin >> elem;
                Push(testStack, elem);

                StackTraverse(testStack);

                break;
            }

            case 2:
            {
                Pop(testStack, elem);

                cout << "弹出 : " << elem << endl;

                StackTraverse(testStack);

                break;
            }

            case 3:
            {
                cout << "栈顶元素 : " << GetTop(testStack) << endl;

                break;
            }
        }
    }


    system("pause");
}

队列

queue.hpp

//链队列

using namespace std;

enum status{OK = 1, ERROR = 0};


typedef int elemType;

typedef struct QNode* QNodePtr;

typedef struct LinkQueue* Queue;

struct  QNode
{
    elemType data;

    QNodePtr next;
};

struct LinkQueue
{
    QNodePtr front;

    QNodePtr rear;

    int qLength = 0;
};

//----------------------------------------初始化----------------------------------------//
status InitQueue(Queue &Q)
{
    Q = new LinkQueue;
    //front和rear都指向头节点
    Q->front = Q->rear = new QNode;

    Q->front->next = nullptr;

    return OK;
}

//----------------------------------------入队----------------------------------------//
status EnQueue(Queue &Q, elemType newElem)
{
    QNodePtr newNode = new QNode;

    newNode->data = newElem;

    newNode->next = nullptr;

    //当队空时front和rear都指向头节点时，Q->rear->next 和 Q->front->next 的值相等
    //此时改变头节点的指针域，Q->rear->next 和 Q->front->next会同时改变
    Q->rear->next = newNode;

    Q->rear = newNode;

    Q->qLength++;

    return OK;
}

//----------------------------------------出队----------------------------------------//
status DeQueue(Queue &Q, elemType &deleteElem)
{
    //(Q->front)是头节点

    if(Q->qLength == 0)
        return ERROR;

    QNodePtr will_DeleteNode = Q->front->next;
    //头节点的下一个是将要删除节点的下一个节点
    Q->front->next = will_DeleteNode->next;

    deleteElem = will_DeleteNode->data;

    delete will_DeleteNode;

    Q->qLength--;

    //如果队列为空，则让尾指针指向头节点
    if(Q->qLength == 0)
        Q->rear = Q->front;

    return OK;
}

//----------------------------------------取队头元素----------------------------------------//
elemType GetHead(Queue &Q)
{
    return Q->front->next->data;
}

//----------------------------------------遍历----------------------------------------//
status QTraverse(Queue &Q)
{
    cout << "队列长度为 " << Q->qLength << " 从头到尾依次为 :" << endl;

    QNodePtr currentNode = Q->front->next;
    int index = Q->qLength;

    while(index != 0)
    {
        cout << currentNode->data << " ";
        currentNode = currentNode->next;

        index--;
    }

    cout << endl;

    return OK;
}

queue_Test.cpp

#include <iostream>
#include "queue.hpp"
using namespace std;

int main()
{
    cout << "## 链队列测试 ##" << endl;

    Queue qTest;

    InitQueue(qTest);

    cout << "请输入数据 : " << endl;
    for(int i=0;;i++)
    {
        
        elemType elem;
        cin >> elem;

        if(elem == 0)
            break;

        EnQueue(qTest, elem);
    }

    QTraverse(qTest);

    cout << "1:入队" << endl;
    cout << "2:出队" << endl;
    cout << "3:取队头元素" << endl;

    while(true)
    {
        int elem;

        int choice;
        cin >> choice;

        switch (choice)
        {
            case 1:
            {
                cout << "请输入入队元素 : ";
                cin >> elem;
                EnQueue(qTest, elem);

                QTraverse(qTest);

                break;
            }

            case 2:
            {
                DeQueue(qTest, elem);

                cout << "出队 : " << elem << endl;

                QTraverse(qTest);

                break;
            }

            case 3:
            {
                cout << "队头元素 : " << GetHead(qTest) << endl;

                break;
            }
        }
    }   


    system("pause");
}