初学栈与队列
建立一个栈的基本流程为
首先定义栈的结构 包括栈的大小 指向栈顶和栈底的指针
1.使用malloc函数开辟一段连续的空间 使top=base=该空间的首地址
2.将数据压入（push）栈中 使用for循环 使得top=压入的数据 然后top+1 指向下一个空间
3.如果预留空间不够大 即(S->top - S->base) / sizeof(SElemType) >= S->size 用realloc函数重新分配即可
几个基本操作
1.栈的构造 见上
2.清空栈 使得top=base 于是下次push时又从头开始 也可以用if(s->top==s->base)来判断是否是空栈
3.判断栈是否满了 if((s->top-s->base)/sizeof(SElemType)==s->size) 那么该栈已满
4.进栈/压栈 见上
5.退栈 只需s->top-1 此时top指向栈顶的元素。
6.取栈顶元素。只是取出该元素，栈不能改变。*e = *(S.top - sizeof(SElemType))即可
7.销毁栈。根据构造栈时的代码 S->base = (SElemType*) malloc(INIT_SIZE * sizeof(SElemType))可知
栈的首地址为s->base 所以只需free(s->base)即可
此时如果再向栈中push数据，会发现仍然可以写入，这是因为top指针和base指针仍旧指向之前的那块地址，所以在销毁栈时，不仅要free(s->base)，还要使s->top=NULL;s->base=NULL.我借鉴的代码上最后还写了【s->size=0】 这段代码我认为是可有可无的 假如有大牛看到这里觉得不对 还请在评论里指点一二。
队列
我觉得栈就是线性表（顺序表），一次性分配一段连续的物理空间来储存
而队列则是单向链表的实现，队列的每个单元都是一个由数据与后继指针组成的结构体，它在物理空间上是不连续的
当然 栈和队列的实现不止于使用线性表 这里只是讨论这一种情况
队列每个元素的构成
首先队列是动态的所以不需要规定一个size，它需要队头指针和队尾指针，而且这两个指针都是一个由数据与指针组成的结构体。
具体代码如下
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
}LinkQueue;
关于队列的基本操作
1.构造空队列
Q->front=Q->rear=malloc(sizeof(Qnode))
此时另前指针front->next=NULL
2.求出队列此时的长度
在子函数中定义一个p，一个计数用的i， 使它等于头指针 while(Q->rear!=p);i++;p=p->next;
3.销毁队列
代码如下
while (Q->front)
{
Q->rear = Q->front->next;
free(Q->front);
Q->front = Q->rear;
}
Q->rear指向离Q->front最近的结点，释放Q->front，Q->front又指向Q->rear即原本的Q->front->next 就是原本离front最近的结点
然后这样依次释放，直到队列被销毁。
4.清空队列
清空队列只需先销毁这个队列，再重新建立一个即可
5.判断是否为空
Q->front->next==NULL?
6.返回队头的元素（若队列不空）
int p=Q.front->next; *e=p->data;
7.插入队尾元素
QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
if (!p)
{
exit(OVERFLOW);
}
p->data = e;
p->next = NULL;
Q->rear->next = p;
Q->rear = p;
8.遍历队列
QueuePtr p = Q.front->next;
while (p)
{
visit(p->data);
p = p->next;
}
因为尾指针rear->next=NULL
OK 现在回顾一下队列的建立基本步骤
队列构成的基本步骤
1.开辟一个结构体（包含数据域和指针域），头指针与尾指针均指向它，并将该结构的指针设为空 NULL
2.要想队列中添加数据时，先开辟一个结构体p，将p的指针设为空，另front也就是此时的rear的指针指向p，再令rear=p；如此循环 即可不断插入数据扩大队列。
3.队列的销毁 清空 获取队列长度 都需要遍历队列。常用方法是
while(Q->front); 当队列存在时
while(p)
{
visit(p->data);
p = p->next;
}
因为最后一个结点的指针为空
QueuePtr p = Q.front;
while (Q.rear != p)
{
i++;
p = p->next;
}
从头指针一直到尾指针
这是我的第一篇 稍微有点技术含量的博客
写了自己对于 栈和队列的理解 虽然很浅 但是还是挺高兴的
最后附上栈与队列的代码
栈
#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define INIT_SIZE 20
#define INCREMENT_SIZE 5
typedef int SElemType;
typedef int Status;
/*
* 存储结构
*/
typedef struct
{
SElemType *base; //栈尾指针
SElemType *top; //栈顶指针
int size; //栈的大小
}SqStack;
/*
* 初始化栈
*/
Status InitStack(SqStack *S)
{
S->base = (SElemType*) malloc(INIT_SIZE * sizeof(SElemType));
if (!S->base)
{
exit(OVERFLOW);
}
S->top = S->base;
S->size = INIT_SIZE;
return OK;
}
/*
* 销毁栈
*/
Status DestroyStack(SqStack *S)
{
free(S->base);
S->base = NULL;
S->top = NULL;
S->size = 0;
return OK;
}
/*
* 清空栈
*/
Status ClearStack(SqStack *S)
{
S->top = S->base;
return OK;
}
/*
* 判断栈是否为空
*/
Status IsEmpty(SqStack S)
{
if (S.top == S.base)
{
return TRUE;
}
else
return FALSE;
}
/*
* 获取栈的长度
*/
int GetLength(SqStack S)
{
return (S.top - S.base) / sizeof(SElemType);
}
/*
* 获取栈顶元素
*/
Status GetTop(SqStack S, SElemType *e)
{
if (S.top > S.base)
{
*e = *(S.top - sizeof(SElemType));
return OK;
}
else
{
return ERROR;
}
}
/*
* 压栈
*/
Status Push(SqStack *S, SElemType e)
{
if ((S->top - S->base) / sizeof(SElemType) >= S->size)
{
S->base = (SElemType*) realloc(S->base, (S->size + INCREMENT_SIZE) * sizeof(SElemType));
if (!S->base)
{
exit(OVERFLOW);
}
S->top = S->base + S->size * sizeof(SElemType);
S->size += INCREMENT_SIZE;
}
*S->top = e;
S->top += sizeof(SElemType);
return OK;
}
/*
* 退栈
*/
Status Pop(SqStack *S, SElemType *e)
{
if (S->top == S->base)
{
return ERROR;
}
S->top -= sizeof(SElemType);
*e = *S->top;
return OK;
}
/*
* 访问元素
*/
void visit(SElemType e)
{
printf("%d ", e);
}
/*
* 遍历栈
*/
Status TraverseStack(SqStack S, void (*visit)(SElemType))
{
while (S.top > S.base)
{
visit(*S.base);
S.base += sizeof(SElemType);
}
return OK;
}
int main()
{
SqStack S;
if (InitStack(&S))
{
SElemType e;
int i;
printf("init_success\n");
if (IsEmpty(S))
{
printf("Stack is empty\n");
}
for (i = 0; i < 10; i++)
{
Push(&S, i);
}
GetTop(S, &e);
printf("The first element is %d\n", e);
printf("length is %d\n", GetLength(S));
Pop(&S, &e);
printf("Pop element is %d\n", e);
TraverseStack(S, *visit);
if (DestroyStack(&S))
{
printf("\ndestroy_success\n");
}
}
}
队列
#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int QElemType;
typedef int Status;
/*
* 存储结构
*/
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
}LinkQueue;
/*
* 初始化队列
*/
Status InitQueue(LinkQueue *Q)
{
Q->front = Q->rear = (QueuePtr) malloc(sizeof(QNode));
if (!Q->front)
{
exit(OVERFLOW);
}
Q->front->next = NULL;
return OK;
}
/*
* 销毁队列
*/
Status DestroyQueue(LinkQueue *Q)
{
while (Q->front)
{
Q->rear = Q->front->next;
free(Q->front);
Q->front = Q->rear;
}
return OK;
}
/*
* 清空队列
*/
Status ClearQueue(LinkQueue *Q)
{
DestroyQueue(Q);
InitQueue(Q);
}
/*
* 判断队列是否为空
*/
Status IsEmpty(LinkQueue Q)
{
if (Q.front->next == NULL)
{
return TRUE;
}
else
{
return FALSE;
}
}
/*
* 获取队列的长度
*/
int GetLength(LinkQueue Q)
{
int i = 0;
QueuePtr p = Q.front;
while (Q.rear != p)
{
i++;
p = p->next;
}
return i;
}
/*
* 获取队头元素
*/
Status GetHead(LinkQueue Q, QElemType *e)
{
QueuePtr p;
if (Q.front == Q.rear)
{
return ERROR;
}
p = Q.front->next;
*e = p->data;
return OK;
}
/*
* 入队
*/
Status EnQueue(LinkQueue *Q, QElemType e)
{
QueuePtr p = (QueuePtr) malloc(sizeof(QNode));
if (!p)
{
exit(OVERFLOW);
}
p->data = e;
p->next = NULL;
Q->rear->next = p;
Q->rear = p;
return OK;
}
/*
* 出队
*/
Status DeQueue(LinkQueue *Q, QElemType *e)
{
QueuePtr p;
if (Q->front == Q->rear)
{
return ERROR;
}
p = Q->front->next;
*e = p->data;
Q->front->next = p->next;
if (Q->rear == p)
{
Q->rear = Q->front;
}
free(p);
return OK;
}
/*
* 访问元素
*/
void visit(QElemType e)
{
printf("%d ", e);
}
/*
* 遍历队列
*/
Status TraverseQueue(LinkQueue Q, void (*visit)(QElemType))
{
QueuePtr p = Q.front->next;
while (p)
{
visit(p->data);
p = p->next;
}
return OK;
}
int main()
{
LinkQueue Q;
if (InitQueue(&Q))
{
QElemType e;
int i;
printf("init_success\n");
if (IsEmpty(Q))
{
printf("queue is empty\n");
}
for (i = 0; i < 10; i++)
{
EnQueue(&Q, i);
}
GetHead(Q, &e);
printf("The first element is %d\n", e);
printf("length is %d\n", GetLength(Q));
DeQueue(&Q, &e);
printf("delete element is %d\n", e);
TraverseQueue(Q, *visit);
if (DestroyQueue(&Q))
{
printf("\ndestroy_success\n");
}
}
}