数据结构--栈和队列记事本

以下为：栈和队列的基操

顺序队列（循环队列）

#include <bits/stdc++.h>
#define MAXSIZE 100
using namespace std;
typedef struct qnode
{
    int data[MAXSIZE];
    int front,rear;
}Queue;
void InitQueue(Queue &q)//这里一定要有地址符
{
    q.front=0;
    q.rear=0;
}
void InQueue(Queue &q,int data)
{
    if((q.rear+1)%MAXSIZE!=q.front)//不为满
    {
       q.data[q.rear]=data;
       q.rear=(q.rear+1)%MAXSIZE;
    }
}
void OutQueue(Queue &q)
{
    int data;
    if(q.front!=q.rear)//不为空
    {
        data=q.data[q.front];
        q.front=(q.front+1)%MAXSIZE;
    }
    cout<<data<<" ";
}
int main()
{
    int x,data;
    Queue Q;
    InitQueue(Q);
    while(cin>>x&&x!=0)
    {
        InQueue(Q,x);
    }
    while(Q.front!=Q.rear)
    {
        OutQueue(Q);
    }
    //cout<<endl;
    return 0;
}

//取队头
int GetHead(Queue &Q)
{
    return Q.data[Q.front]; 
}
//判空
int QueueEmpty(Queue &Q)
{
    if(Q.front==Q.rear)return 1;
    else return 0;
}

链队列

new和delete配套
malloc和free配套

#include <bits/stdc++.h>
using namespace std;
#define MAXSIZE 100
typedef struct node
{
    int data;
    struct node *next;
}QNode,*LinkQNode;
//封装头尾指针
typedef struct
{
    LinkQNode front,rear;
}Queue;
//初始化：创建带头结点的空队
void InitQueue(Queue &Q)
{
    Q.front=Q.rear=new QNode;//指针申请存储空间
    if(!Q.front)//队头节点为空
    {
        cout<<"Error";
        return 0;
    }
    Q.front->next=NULL;
    return 1；
}
//入队
void QueueIn(Queue &Q,int x)
{
    LinkQNode p;//指针
    p=new QNode;//申请空间
    p->data=x;
    p->next=NULL;
    //从队尾插入，用尾插法
    Q.rear->next=p;
    Q.rear=p;
}
//出队
int QueueOut(Queue &Q)
{
    int x;
    LinkQNode p;
    if(Q.front!=Q.rear)//不为空
    {
        p=Q.front->next;//由于队列有头结点
        x=p->data;
        Q.front->next=p->next;
        if(Q.rear==p)//仅一个元素
        {
            Q.rear=Q.front;//出队后，队空
        }
        delete(p);
        return x; 
    }
}

//判空
int QueueEmpty(Queue Q)
{
    if(Q.front==Q.rear)return 1;
    else return 0;
}

以下为栈--------------------------------------------------------------------------------------

链栈

#include <bits/stdc++.h>
using namespace std;
#define MAXSIZE 100
typedef struct snode
{
    int data;
    struct sode *next;
}SNode,*LinkStack;
//由于栈只在栈顶操作，因此，通常不设头结点


//初始化：创建空栈，栈顶top
void InitStack(LinkStack &top)
{
    top=NULL;
}
//判栈空
int StackEmpty(LinkStack top)
{
    if(top==NULL)return 1;
    else return 0;
}
//入栈
void StackIn(LinkStack &top,int x)
{
    //栈top头插x，变更新top
    LinkStack s;//指针
    s=new SNode;//申请
    s->data=x;  //存储
    //头插
    s->next=top;
    top=s;
}
//出栈
int StackOut(LinkStack &top)
{
    int x;
    LinkStack P;//指针p
    //出栈前提：栈不为空
    if(top!=NULL)
    {
        x=top->data;
        p=top;
        top=top->next;
        free(p);
        return x;
    }
  
}

顺序栈

#include <bits/stdc++.h>
//顺序栈的输入输出
using namespace std;
#define MAXSIZE 10000
typedef struct
{
    int top;
    int bottom;
    int data[MAXSIZE];
}Stack;

void InitStack(Stack &s)//初始化
{
    s.bottom=0;
    s.top=0;
    memset(s.data,0,sizeof(s.data));
}

int StackPop(Stack &s)//出栈
{
    if(s.bottom!=s.top){
        s.top--;
    return s.data[s.top+1];
    }
}

void StackPush(Stack &s,int x)//入栈
{
    s.top++;
    s.data[s.top]=x;
}
int main()
{
    Stack s;
    InitStack(s);
    int data;
    while(cin>>data&&data!=0)  //输入
        StackPush(s,data);
    while(s.bottom!=s.top)    //输出
        cout<<StackPop(s)<<" ";
   // cout << "Hello world!" << endl;
    return 0;
}

顺序栈（双向栈）

在这里未完