基础数据结构（栈，队列）

栈和队列都是最基础的数据结构，栈的思想是“先进后出”，队列的思想是“先进先出”。怎么说呢，栈和队列其实都是对于单链表或者数组的一些特殊操作。在后边很多算法中经常用到（比如BFS， SPFA。。。）

栈主要操作有：

入栈Push；

取栈顶Get_Top;

出栈（删除栈顶元素）Pop；

栈的数组实现（代码非常简单，关键是思想）：

//数组实现
#include <stdio.h>
#include <malloc.h>
#define maxsize 10
typedef struct
{
    int data[maxsize];
    int top;
    int base;
}seqstack;
seqstack * s;
void initstack(seqstack * s)
{
    s->top = 0;
    s->base = 0;
}
int empty(seqstack * s)
{
    if(s->top == s->base)
        return 1;
    else
        return 0;
}
void  push(seqstack * s, int x)
{
    if(s->top >= maxsize-1)
    {
        printf("ERROR!\n");
    }
    else
    {
        s->data[s->top] = x;
        s->top++;
    }
}
void  pop(seqstack * s)
{
    if(empty(s))
    {
        printf("ERROR!\n");
    }
    else
    {
        s->top--;
        printf("%d\n",s->data[s->top]);
    }
}
int main()
{
    seqstack * s;
    s = (seqstack *)malloc(sizeof(seqstack));
    
    initstack(s);
    push(s,1);
    push(s,3);
    pop(s);
    push(s,2);
    pop(s);
    pop(s);
    pop(s);
    return 0;
}

单链表实现：

//链式
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node *next;
}node,linkstack;
void InitStack(linkstack * top)
{
    top->next = NULL;
}
int IsEmpty(linkstack * top)
{
    if(top->next == NULL) return 1;
    return 0;
}
int Push(linkstack * top, int x)
{
    node * p;    
    p = (node *)malloc(sizeof(node));
    if(p == NULL) return 0;
    p->data = x;
    p->next = top->next;
    top->next = p;
    return 1;
}
int Pop(linkstack * top, int *x)
{
    node * p;
    if(IsEmpty(top))
    {
        printf("ERROE!\n");
        return 0;
    }
    p = top->next;
    *x = p->data;
    top->next = p->next;
    free(p);
    return 1;
}
int main()
{
    int x;
    linkstack * s;
    s = (linkstack *)malloc(sizeof(linkstack));
    InitStack(s);
    Push(s,1);
    Push(s,3);
    Pop(s,&x);
    printf("%d\n",x);
    Push(s,2);
    Pop(s,&x);
    printf("%d\n",x);
    Pop(s,&x);
    printf("%d\n",x);
    Pop(s,&x);
    return 0;
}

队列的操作与栈类似，这里不赘述了，且看代码实现：

//数组实现
#include <stdio.h>
#include <malloc.h>
#define maxsize 66
typedef struct
{
    int data[maxsize];
    int front,rear;
}sequeue;
sequeue * q;
void initqueue(sequeue *q)
{
    q->front = -1;
    q->rear = -1;
}
int del(sequeue *q)
{
    if(q->front == q->rear)
        return NULL;
    else
    {
        q->front++;
        return q->data[q->front];
    }
}
int insertqueue(sequeue *q,int x)
{
    if(q->rear >= maxsize-1)
        return NULL;
    else
    {
        (q->rear)++;
        q->data[q->rear] = x;
        return 1;
    }
}
int empty(sequeue * q)
{
    if(q->front == q->rear)
        return 0;
    else
        return 1;
}
void print(sequeue * q)
{
    if(q->front == q->rear)
        printf("ERROR!\n");
    else
    {
        while(empty(q))
        {
            q->front++;
            printf("%d\n",q->data[q->front]);
        }
    }
}
int main()
{
    int i;
    sequeue * q;
    q  = (sequeue *)malloc(sizeof(sequeue));
    initqueue(q);
    for(i = 0; i < 6; i++)
        insertqueue(q,i);
    printf("front is %d\n\n",del(q));
    printf("Then the last data is:\n");
    print(q);
    return 0;
}

//链表实现

#include <stdio.h>
#include <malloc.h>
typedef struct node
{
    int data;
    struct node * next;
}linklist;
typedef struct
{
    linklist * front, * rear;
}linkqueue;
linkqueue * q;
//建立队列
void initqueue(linkqueue * q)
{
    q->front = (linkqueue *)malloc(sizeof(linklist));
    q->front->next = NULL;
    q->rear = q->front;
}
//判断队列空否
int empty(linkqueue * q)
{
    if(q->front == q->rear)
        return 1;
    else
        return 0;
}
//入队列
void inqueue(linkqueue * q, int x)
{
    q->rear->next = (linklist *)malloc(sizeof(linklist));
    q->rear->next->data = x;
    q->rear = q->rear->next;
    q->rear->next = NULL;
}
//出队列
int outqueue(linkqueue * q)
{
    linklist * s;
    if(empty(q))
        return NULL;
    else
    {
        s = q->front->next;
        printf("%d\n",s->data);
        if(s == q->rear)
            q->front = q->rear;
        else
            q->front->next = s->next;
        free(s);
        return 1;
    }
}
//main
int main()
{
    int i;
    linkqueue * l;
    l = (linkqueue *)malloc(sizeof(linkqueue));
    initqueue(l);
    for(i = 0; i < 10; i++)
        inqueue(l,i);
    for(i = 0; i < 10; i++)
        outqueue(l);
    
    return 0;
}

ps:转自http://www.cnblogs.com/vongang/