数据结构-3.4-栈与队列

学习资料：数据结构C语言版 清华大学出版社（以后的略）

这次一次过把栈和队列都写好了。栈和队列 存储结构和顺序表有些像。不过栈是先进后出，队列是先进先出。

栈和队列的应用其实还是挺多的，不过我属于入门学习阶段……所以就先把最基本的代码给实现了……学完整本课内要求的数据结构内容后会将这些各种各样的数据结构应用在别的题目上的！！！

栈：时限定仅在表尾进行插入或者删除操作的线性表。表尾成为栈顶，表头段称为栈底。不含元素的栈称为空栈。

栈的实现：

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define STACK_INIT_SIZE 100//存储空间的初始分配量
#define STACKINCREMENT 10//存储空间分配增量

typedef int Status;
typedef int Selemtype;
typedef struct node
{
    int data;
    struct node *next;
} Stack;


Status IsEmpty(Stack *t)
{
    if(t->next==NULL)
    {
        return TRUE;
    }
    return FALSE;
}
void InitStack(Stack *top)
{
    top->next=NULL;//将栈顶设为空
}
Status Push(Stack *top,Selemtype e)
{
    //创造新的节点 存放传入的e
    Stack *p;
    p=(Stack*)malloc(sizeof(Stack));
    if(p==NULL)
    {
        return 0;
    }
    p->data=e;
    p->next=top->next;
    top->next=p;
    return OK;
}
Status Pop(Stack *top,Selemtype &e)
{
    if(IsEmpty(top)) return 0;
    Stack *p;
    p=top->next;//栈顶下面第一个节点是要出栈的
    e=p->data;
    top->next=p->next;//栈内元素的前移
    free(p);
    return OK;
}


int main()
{
    int a;
    Stack *top=(Stack*)malloc(sizeof(Stack));//生成一个栈顶指针
    InitStack(top);
    while(~scanf("%d",&a))
    {
        Push(top,a);
    }
    Stack *p=top->next;
    printf("the elemet in the stack:
");
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    cout<<endl;

    int x;
    Pop(top,x);
    cout<<"The ele that you delete is "<<x<<" ."<<endl;

    p=top->next;
    printf("the elemet in the stack:
");
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    p=NULL;

    cout<<endl;
    cout<<"Now pop all the data:"<<endl;
    while(Pop(top,x))
    {
        printf("%d ",x);
    }
    cout<<endl;
    free(top);
    return 0;
}

功能函数：

1、IsEmpty：判断栈是否为空，传入指向头结点的指针，判断栈顶项是否为空。若为空返回true，否则返回false。

2、InitStack：使传入的头结点指针一个指为空。

3、Push：创造一个新的结点（分配相应的存储空间），在该生成的结点的数据域里面存放传入的Selemtype e。该生成的结点放在栈顶位置，原栈顶元素及以下均往后推一个位置。（实现的时候只是改变了指针的指向，像单链表）。

4、Pop：需要判断栈是否为空。生成一个指向栈的指针指向栈顶元素，释放栈顶元素的空间，原指向栈顶的头指针指向栈顶指向的next地址。会将出栈数据赋值到传入的Selemtype e上。方便输出检查结果。

5、主函数：对上述几个函数进行了相应的测试。先为栈顶分配sizeof(Stack)的内存空间，调用InitStack函数将栈置空。将栈置空后调用Push函数，以ctrl+z结束输入。输入一定的数据，将数据按顺序压入栈内，再调将压入栈内的元素按照从栈顶到栈尾的顺序输出（其实我觉得我可以将这一段再写一个小函数，使代码功能划分更强……）。调用Pop函数删除栈顶元素后再遍历输出一次栈内元素。最后顺序调用Pop函数将所有剩余的存储的数据出栈。

{写到这里我想到了一个问题，为什么每一次分配内存空间的时候都要将分配的内存空间置空（或者清0）呢？

询问了老师和百度了一下才知道原来（不要打我，我真的今天才知道这么一回事……以前都是按照书本代码养成的习惯……）在分配新的内存空间的时候这个空间里原本是存放着一些数据的。按理来说，是可以直接使用这段内存，可是万一存放的时候存在没有存放新数据但是却分配了内存的空间段，在检查结果输出数据的时候很可能会把原来存放在这个内存空间里的数据输出来，可能会造成难以发现的错误。}

队列：是一种先进先出的线性表结构。只允许在表的一端插入，在另一端删除元素。类似我们日常生活中的排队。允许插入的一端称为队尾，删除的一端称为队头。这里用了链队列的链式表示实现的代码。

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef int Status;
typedef int ElemType;

//定义队列
typedef struct node{
    int data;
    struct node *next;
}Queue;
//定义队首队尾
typedef struct pointer{
    Queue *front;//队首指针，不存放队列元素(类似链表中的表头
    Queue *rear;//队尾指针，存放队尾的数据元素
}Qpointer;

//队列的初始化
void QueueInit(Qpointer *qp)
{
    Queue *que;
    que=(Queue*)malloc(sizeof(Queue));
    que->next=NULL;//队首和队尾指向同一个内存空间，指针域为NULL
    qp->front=que;
    qp->rear=que;
}

int IsEmpty(Qpointer *qp)
{
    if(qp->front==qp->rear)
    {
        return TRUE;
    }
    return FALSE;
}

int QueuePush(Qpointer *qp,int e)
{
    Queue *que;
    que=(Queue*)malloc(sizeof(Queue));//为新生成的结点分配内存空间
    if(que==NULL)
    {
        return 0;
    }
    que->data=e;
    que->next=NULL;
    qp->rear->next=que;//将节点插入队列尾
    qp->rear=que;
    return 0;
}
int QueuePop(Qpointer *qp,int *e)
{
    Queue *que;
    if(IsEmpty(qp))
    {
        return 0;
    }
    que=qp->front->next;//que指向队列头结点的下一个节点，即真正的队首
    *e=que->data;//将要出队列的元素
    qp->front->next=que->next;
    //判断队列是否就只剩下一个元素
    if(qp->rear==que)
    {
        qp->rear=qp->front;
    }
    free(que);
    return OK;
}

int main()
{
    Qpointer *qp;
    int x;//队列的初始化
    qp=(Qpointer*)malloc(sizeof(Qpointer));
    QueueInit(qp);

    scanf("%d",&x);//以零结束
    while(x!=0)
    {
        QueuePush(qp,x);
        scanf("%d",&x);
    }
    cout<<"Now output the queue. "<<endl;
    Queue *p=qp->front->next;
    if(p==NULL)    return 0;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("
");
    //队列的删除

    printf("delete the first data of queue:
");
    QueuePop(qp,&x);
    p=qp->front->next;
    if(p==NULL)
    return 0;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    cout<<endl;
    //队列的最后删除
    printf("delete queue:
");
    while(QueuePop(qp,&x))
    {
        printf("%d ",x);
    }
    printf("
");
    p=qp->front;
    free(p);
    free(qp);
    return 0;

}

队列的定义：使用了两个结构体去定义队列。node结构体定义了一个数据域和一个指针域。pointer定义了队首指针和队尾指针，其中队首指针指向的node数据域为空，队尾指针指向的node存放队尾的数据元素。

1、QueueInit：队列的初始化。在主函数中会生成一个指向Queue的指针。传入这个指针，为其分配sizeof（Queue）的内存空间。并使队首和队尾指向同一个内存空间。

2、IsEmpty：判断队列是否为空。判断方法：队首指针和队尾指针是否相同。是返回true，否则返回false。

3、QueuePush：为新生成的结点分配内存空间，需要判断队列是否为空。（为啥呢……）将传入的e值赋给新生成结点的数据域。将新生成结点插入到队尾。

4、QueuePop：需要判断队列是否为空。将要出队的元素赋值给传入的地址e方便输入检查结果。需要最后判断一下队列是否只剩下了一个元素，如果是的话就要将队列的队首赋值给队尾（好销毁）。最后释放que指针。

5、主函数：队列的初始化，先生成一个指向Qpointer的指针，为其分配内存空间。调用QueueInit函数初始化。输入数据以0结束（原本想用~scanf来写，可是不知道为什么不好使了……改了就出错……）调用QueuePush函数再次将输入的数据入队。顺序输出输入的函数（其实我觉得可以写一个void的函数来实现这个过程……）。调用QueuePop函数，将队首元素出队，再遍历输入队里的数据。最后像栈一样多次调用QueuePop函数将所有队员出队，最后销毁指针，释放内存空间。

实现了基础的栈和队列……比较开心。