数据结构 C++实现 栈和队列

一、顺序栈 

#include <iostream>
using namespace std;

#define MAXSIZE 100                     //MAXSIZE为栈分配的最大空间
typedef int ElemType;
typedef struct
{
    ElemType* base;
    ElemType* top;
    int stack_size;
}SqStack;

/*建栈*/
void Create(SqStack &S)
{
    S.base = new ElemType[MAXSIZE];
    if(!S.base)
        return;
    S.top = S.base;                     //top指向栈顶元素的【相邻空位】，base指向栈底元素，建栈时栈空
    S.stack_size = MAXSIZE;
 }

/*入栈*/
void Push(SqStack &S, ElemType e)
{
   if(S.top - S.base == S.stack_size)   //判断栈满的条件
        return;
   *S.top = e;
   S.top++;
}

/*出栈*/
void Pop(SqStack &S, ElemType &e)
{
     if(S.top == S.base)              //判断空栈的条件
        return;
     *S.top--;
     e = *S.top;
}

/*返回栈顶元素*/
ElemType Top(SqStack S)
{
   if(S.top != S.base)
      return *(--S.top);              //返回栈顶元素的值，栈顶指针不变
}

/*遍历栈中的元素*/
void PrintSqStack(SqStack S)
{
    while(S.top != S.base)
    {
        S.top--;
        cout << *S.top << " ";
    }
    cout << endl;
}

int main()
{
    SqStack* S1 = new SqStack;
    Create(*S1);
    int num;
    cout << "输入入栈的元素数量：" ;
    cin >> num;

    for(int i = 0; i < num; i++)
    {
      ElemType j;
      cout << "输入要入栈的第" << i+1 << "个元素：";
      cin >> j;
      Push(*S1, j);
    }

    cout << "遍历栈中的元素：" << endl;
    PrintSqStack(*S1);

    cout << "依次弹出栈顶元素：\n";
    for(int i = 0; i < num; i++)
    {
        ElemType e;
        Pop(*S1, e);
        cout << e << " ";
    }
    return 0;
}

二、链栈 

/*链栈*/
typedef int ElemType;
typedef struct StackNode
{
   ElemType data;
   struct StackNode* next;
}StackNode, *LinkStack;

void Create(LinkStack &S)
{
    S = NULL;         //S为栈顶指针
}

void Push(LinkStack &S, ElemType e)
{
   LinkStack p = new StackNode;
   p->data = e;
   p->next = S;      //新结点入栈,尾插法
   S = p;
}

void Pop(LinkStack &S, ElemType &e)
{
    if(S == NULL)
        return ;
    e = S->data;
    LinkStack p = S;
    S = S->next;
    delete p;            //释放空间
}

ElemType Top(LinkStack S)
{
   if(S != NULL)
      return S->data;
}

void PrintLinkStack(LinkStack S)
{
    while(S != NULL)
    {
        cout << S->data << " ";
        S = S->next;
    }
    cout << endl;
}

int main()
{
    LinkStack S2 = new StackNode;
    Create(S2);
    int num;
    cout << "输入入栈的元素数量：" ;
    cin >> num;
    for(int i = 0; i < num; i++)
    {
      ElemType j;
      cout << "输入要入栈的第" << i+1 << "个元素：";
      cin >> j;
      Push(S2, j);
    }

    cout << "遍历栈中的元素：" << endl;
    PrintLinkStack(S2);

    cout << "依次弹出栈顶元素：\n";
    for(int i = 0; i < num; i++)
    {
        ElemType e;
        Pop(S2, e);
        cout << e << " ";
    }
    return 0;
}

三、顺序循环队列

#include<iostream>
using namespace std;

/*循环队列的顺序存储结构*/
#define MAXSIZE 100
typedef int ElemType;
typedef struct SqQueue
{
    ElemType base[MAXSIZE];
    int front;
    int rear;
}*P;

/*建队*/
void Create(SqQueue &Q)
{
    P p = new SqQueue;
    Q = *p;
    if(p != NULL)
    {
        Q.front = 0;
        Q.rear = 0;
    }
}

/*入队*/
void EnQueue(SqQueue &Q, ElemType e)
{
    if((Q.rear + 1) % MAXSIZE == Q.front)  //判断队满，此处采用【少用一个元素空间】的办法来区分队满和队空,队满时rear表示一个空元素位置
        return;

    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1) % MAXSIZE;
}

/*出队*/
void DeQueue(SqQueue &Q, ElemType &e)
{
    if(Q.rear == Q.front)                 //判断队空
        return;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXSIZE;
}

/*取队首元素*/
ElemType Front(SqQueue Q)
{
    if(Q.rear == Q.front)                 //判断队空
        return '0';

    return Q.base[Q.front];
}

void PrintSqQueue(SqQueue Q)
{
    while(Q.rear != Q.front)
    {
        cout << Q.base[Q.front] << " ";
        Q.front = (Q.front + 1) % MAXSIZE;
    }
    cout << endl;
}

int main()
{
    P Q1 = new SqQueue;
    Create(*Q1);

    int num;
    cout << "输入入队的元素数量：" ;
    cin >> num;
    for(int i = 0; i < num; i++)
    {
      ElemType j;
      cout << "输入要入队的第" << i+1 << "个元素：";
      cin >> j;
      EnQueue(*Q1, j);
    }

    cout << "遍历循环队列：" << endl;
    PrintSqQueue(*Q1);

    cout << "队首元素依次出队：\n";
    for(int i = 0; i < num; i++)
    {
        ElemType e;
        DeQueue(*Q1, e);
        cout << e << " ";
    }

    return 0;
}

四、链队列 

#include<iostream>
using namespace std;

/*链队列*/
typedef int ElemType;
typedef struct QNode            //定义链队列结点，每个节点都有一个数据域和指针域
{
    ElemType data;
    struct QNode* next;
}QNode, *QueuePtr;

typedef struct                  //定义链队列，每个链队列包含一个队首指针和队尾指针
{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

/*建队*/
void Create(LinkQueue &Q)       //为了方便，给队列增加了一个头结点
{
    Q.rear = new QNode;
    Q.front = Q.rear;
    Q.front->next = NULL;
}

/*入队*/
void EnQueue(LinkQueue &Q, ElemType e)
{
    QueuePtr P = new QNode;      //新插入的结点作为上一个队尾结点的next指向的结点，新结点的next为null
    P->data = e;
    P->next = NULL;
    Q.rear->next = P;
    Q.rear = P;                 //修改队尾指针；队尾指针指向队尾结点
}

/*出队*/
void DeQueue(LinkQueue &Q, ElemType &e)
{
    if(Q.rear == Q.front)                 //判断队空
        return;
    QueuePtr P = Q.front->next;           //front指向头结点（data为空），定义指针P指向队首结点
    e = P->data;
    Q.front->next = P->next;
    if(Q.rear == P)                       //如果出队的是队尾结点，对rear重新赋值防止rear丢失
        Q.rear = Q.front;                 //释放结点空间
    delete P;
}

/*取队首元素*/
ElemType Front(LinkQueue Q)
{
    if(Q.rear == Q.front)                 //判断队空
        return '0';

    return Q.front->next->data;
}

void PrintLinkQueue(LinkQueue Q)
{
    QueuePtr p = Q.front->next;
    while(p)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

int main()
{
    LinkQueue* Q2 = new LinkQueue;
    Create(*Q2);

    int num;
    cout << "输入入队的元素数量：" ;
    cin >> num;
    for(int i = 0; i < num; i++)
    {
      ElemType j;
      cout << "输入要入队的第" << i+1 << "个元素：";
      cin >> j;
      EnQueue(*Q2, j);
    }

    cout << "从队首到队尾遍历链队列：" ;
    PrintLinkQueue(*Q2);

    for(int i = 0; i < num; i++)
    {
        ElemType e;
        DeQueue(*Q2, e);
        cout << "队首元素" << e << "出队, ";
        cout << "此时队列为：";
        PrintLinkQueue(*Q2);
    }

    return 0;
}