【黑马程序员-学习笔记】数据结构-栈与队列

一、栈

栈是限制在表的一端进行插入和删除的线性表。允许插入、删除的这一端称为栈顶，另一个固定端称为栈底。当表中没有元素时称为空栈。如图3.1.1 所示栈中有三个元素，进栈的顺序是a1、a2、a3，当需要出栈时其顺序为a3、a2、a1，所以栈又称为后进先出的线性表（Last In First Out），简称LIFO 表。

⑴ 置空栈：首先建立栈空间，然后初始化栈顶指针。
SeqStack *Init_SeqStack()
{ SeqStack *s;
s=malloc(sizeof(SeqStack));
s->top= -1; return s;
}
⑵ 判空栈
int Empty_SeqStack(SeqStack *s)
{ if (s->top= = -1) return 1;
else return 0;
}
⑶ 入栈
int Push_SeqStack (SeqStack *s, datatype x)
{if (s->top= =MAXSIZE-1) return 0; /*栈满不能入栈*/
else { s->top++;
s->data[s->top]=x;
return 1;
}
}
⑷ 出栈
int Pop_SeqStack(SeqStack *s, datatype *x)
{ if (Empty_SeqStack ( s ) ) return 0; /*栈空不能出栈*/
else { *x=s->data[s->top];
s->top--; return 1; } /*栈顶元素存入*x，返回*/
}
⑸ 取栈顶元素
datatype Top_SeqStack(SeqStack *s)
{ if ( Empty_SeqStack ( s ) ) return 0; /*栈空*/
else return (s->data[s->top] );
}

二、链栈

用链式存储结构实现的栈称为链栈。通常链栈用单链表表示，因此其结点结构与单链表的结构相同，在此用LinkStack 表示，即有：
typedef struct node
{ datatype data;
struct node *next;
}StackNode，* LinkStack;

⑴ 置空栈
LinkStack Init_LinkStack（）
{ return NULL;
}
⑵ 判栈空
int Empty_LinkStack（LinkStack top ）

{ if（top==-1） return 1;
else return 0;
}
⑶ 入栈
LinkStack Push_LinkStack（LinkStack top, datatype x）
{ StackNode *s;
s=malloc（sizeof（StackNode））;
s->data=x;
s->next=top;
top=s;
return top;
}
⑷ 出栈
LinkStack Pop_LinkStack (LinkStack top, datatype *x)
{ StackNode *p;
if （top= =NULL） return NULL;
else { *x = top->data;
p = top;
top = top->next;
free (p);
return top;
}
}

三、队列

插入在表一端进行，而删除在表的另一端进行，这种数据结构称为队或队列，把允许插入的一端叫队尾(rear) ，把允许删除的一端叫队头(front)。如图3.11 所示是一个有5 个元素的队列。入队的顺序依次为a1、a2 、a3 、a4 、a5 ，出队时的顺序将依然是a1、a2 、a3 、a4 、a5 。

显然，队列也是一种运算受限制的线性表，所以又叫先进先出表。

⑴ 置空队
c_SeQueue* Init_SeQueue()
{ q=malloc(sizeof(c_SeQueue));
q->front=q->rear=MAXSIZE-1;
q->num=0;
return q;
}
⑵ 入队
int In_SeQueue ( c_SeQueue *q , datatype x)
{ if (num==MAXSIZE)
{ printf(＂队满＂);
return –1; /*队满不能入队*/
}
else
{ q->rear=(q->rear+1) % MAXSIZE;
q->data[q->rear]=x;
num++;
return 1; /*入队完成*/
}
}
⑶ 出队
int Out_SeQueue (c_SeQueue *q , datatype *x)
{ if (num==0)
{ printf(＂队空＂)；
return –1; /*队空不能出队*/
}
else
{ q->front=(q->front+1) % MAXSIZE;
*x=q->data[q->front]; /*读出队头元素*/
num--;
return 1; /*出队完成*/
}
}
⑷ 判队空
int Empty_SeQueue(c_SeQueue *q)
{ if (num==0) return 1;
else return 0;
}

三、 链队

链式存储的队称为链队。和链栈类似，用单链表来实现链队，根据队的FIFO 原则，为了操作上的方便，我们分别需要一个头指针和尾指针，如图3.15 所示 。

链队的基本运算如下：
(1) 创建一个带头结点的空队：
LQueue *Init_LQueue()
{ LQueue *q,*p;
q=malloc(sizeof(LQueue)); /*申请头尾指针结点*/
p=malloc(sizeof(QNode)); /*申请链队头结点*/
p->next=NULL; q->front=q->rear=p;
return q;
}
(2) 入队
void In_LQueue(LQueue *q , datatype x)
{ QNode *p;
p=malloc(sizeof(QNnode)); /*申请新结点*/
p->data=x; p->next=NULL;
q->rear->next=p;
q->rear=p;
}
(3) 判队空
int Empty_LQueue( LQueue *q)
{ if (q->front==q->rear) return 0;
else return 1;
}
(4) 出队
int Out_LQueue(LQueue *q , datatype *x)
{ QNnode *p;
if (Empty_LQueue(q) )
{ printf (＂队空＂)； return 0;
} /*队空，出队失败*/
else
{ p=q->front->neat;
q->front->next=p->next;
*x=p->data;/*队头元素放x 中*/
free(p);
if (q->front->next==NULL)
q->rear=q->front;
/*只有一个元素时，出队后队空，此时还要要修改队尾指针参考图3.16(c)*/
return 1;
}
}