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

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