C语言实现,顺序队列，循环队列，和栈！

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。

顺序队列代码实现：

#include <stdio.h>
#define MAX 10

typedef struct Queue
{
    int date[MAX];
    int front;
    int tial;
}queue;

queue a;

void IniQueue() //初始化
{
    a.tial = 0;
    a.front = 0;
}

int isEmpty()
{
    if(a.front == 0)     //队列为空
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int push_Queue(int data)    //入队
{
    if(a.front == MAX-1)  //队列已满
    {
        return 1;
    }
    else
    {
        a.date[a.front] = data;
    }
    a.front++;
    return 0;
}

int pop_Queue()     //出队
{
    if(!isEmpty())  //不为空
    {
        a.date[a.front--];
       // printf("%d\n",a.front);
    }

    return 0;
}

void show()     //遍历
{
    int i = 0;
    for(i = 0; i < a.front;i++ )
    {
        printf("%d\n",a.date[i]);
    }
}

int main(void)
{
    printf("Hello World!\n");
    push_Queue(1);
    push_Queue(2);
    push_Queue(3);
    push_Queue(4);
    push_Queue(5);
    push_Queue(6);
    push_Queue(7);
    show();
    puts("==================");
    pop_Queue();
    show();
    return 0;
}

循环队列

在实际使用队列时，为了使队列空间能重复使用，往往对队列的使用方法稍加改进：无论插入或删除，一旦rear指针增1或front指针增1 时超出了所分配的队列空间，就让它指向这片连续空间的起始位置。自己真从MaxSize-1增1变到0，可用取余运算rear%MaxSize和front%MaxSize来实现。这实际上是把队列空间想象成一个环形空间，环形空间中的存储单元循环使用，用这种方法管理的队列也就称为循环队列。除了一些简单应用之外，真正实用的队列是循环队列。 

在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时，也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。

#include <stdio.h>
#define MAX 1000

typedef struct Queues
{
    int date[MAX];
    int front;//头
    int tail;//尾
}Queue;

Queue queue;

void CreatQueue()
{
    queue.front = 0;
    queue.tail = 0;
}

void push_back(int vaule)   //入队
{
    if((queue.tail +1)%MAX != queue.front)//队列未满
    {
        queue.tail = (queue.tail+1)%MAX;//因为少用一个，加1，才到尾；//%MAX是为了提高准确度
        queue.date[queue.tail] = vaule;
    }
    else
    {
        printf("full\n");
    }
}

int pop_Queue()     //出队
{
    if(queue.front != queue.tail)//队列不为空
    {
        int vaule = queue.date[queue.front+1];//先进先出
        queue.front = (queue.front+1)%MAX;
        return vaule;
    }
    return 0;
}

int main()
{
    CreatQueue();
    int i = 0;

    for(i = 1;i <= 5;i++)
    {
        push_back(i);
        printf("%d\n",queue.date[i]);
    }
    printf("==============\n");
    for(i = 1;i <= 5;i++)
    {
        printf("%d\n",pop_Queue());
    }
    return 0;
}

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。
栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为后进先出表。

#include <stdio.h>
#include <stdlib.h>

typedef struct node     //节点
{
    int member;
    struct node* next;
}Node,*pNode;

typedef struct stack
{
    pNode Top;          //栈顶
    pNode Buttom;       //栈底
}Stack,*pStack;

void InitStack(pStack ps)       //初始化栈
{
    ps->Top = (pNode)malloc(sizeof(Node));
    if(NULL == ps)
    {
        printf("malloc error\n");
        exit(-1);
    }
    else
    {
        ps->Buttom = ps->Top;
        ps->Top->next = NULL;
    }
}

int push_stack(pStack ps,int data)      //压栈
{
    pNode New = (pNode)malloc(sizeof(Node));
    if(NULL == New)
    {
        printf("push_stack error\n");
        return 0;
    }
    else
    {
        New->member = data;
        New->next = ps->Top;
        ps->Top = New;
        return 1;
    }
}

void ShowStack(pStack ps)       //遍历栈
{
    pNode New = ps->Top;
    while(New != ps->Buttom)
    {
        printf("%d\n",New->member);
        New = New->next;
    }
}

int Empty(pStack ps)        //判断栈是否为空
{
    if(ps->Top == ps->Buttom)
    {
        printf("stack is NULL\n");
        return 1;
    }
    else
    {
        printf("stack no NULL\n");
        return 0;
    }
}

int pop_stack(pStack ps)    //出栈
{
    pNode swap = NULL;
    int vaule = 0;
    if(1 == Empty(ps))
    {
        exit(-1);
    }
    else
    {
        vaule = ps->Top->member;
        swap = ps->Top;
        ps->Top = ps->Top->next;
        free(swap);
        swap = NULL;
        return vaule;
    }
}

void clear(pStack ps)       //清空栈
{
    pNode cnode = NULL;
    while(ps->Top != ps->Buttom)    //栈不为空
    {
        cnode = ps->Top;
        ps->Top = ps->Top->next;
        free(cnode);
        cnode = NULL;
    }
}

int main()
{
    Stack s;
    int i = 0;
    int num = 0;
    int data = 0;
    int re_num = 0;
    InitStack(&s);
    printf("Do you want how num?\n");
    scanf("%d",&num);
    for(i = 0; i < num;i++)
    {
        printf("at %d num:",i+1);
        scanf("%d",&data);
        if(push_stack(&s,data))
        {
            continue;
        }
        else
        {
            printf("push_stack error\n");
            exit(-1);
        }
    }
    ShowStack(&s);
    return 0;
}

编译环境：Qt5.3.2