用双向链表实现一个栈和队列

下面将介绍一下，如何使用双向链表来分别实现“堆栈”和“队列”，其中有的部分是一样，所以就直接调用了。

堆栈：后进先出，入栈和出栈都是在栈顶进行；

队列：先进先出，在队列尾插入元素，从队列头删除元素。

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

// 判断堆栈是否为空
// 为空,返回1;不为空,返回0
static int StackIsEmpty(List *plist)
{
if(plist->count==0)
return 1;
else
return 0;
}

// 判断堆栈是否为满
// 为满,返回1;不为满,返回0
static int StackIsFull(List *plist)
{
if(plist->count==plist->max)
return 1;
else
return 0;
}

// 堆栈初始化
// 建立一个带哨兵的空链表
// 失败,返回0;成功:返回1
int StackInit(List *plist,int length)
{
struct node* pnew;
pnew=(struct node*)malloc(sizeof(struct node));
if(pnew==0)
{
return 0;
}
pnew->next=pnew;
pnew->prev=pnew;
plist->head=pnew; //哨兵元素,头指针指向头结点

plist->count=0;
plist->max=length;

return 1;
}

//压栈(在双向链表的头部添加一个元素)
// 将元素添加到链表头(哨兵元素之后)
// 成功,返回1;失败,返回0
int StackPush(List *plist,Item item)
{
struct node *pnew;
if(StackIsFull(plist))//若栈满，返回0
return 0;
pnew=(struct node*)malloc(sizeof(struct node));
if(pnew==0)
return 0;

pnew->item=item;
pnew->prev=plist->head;
pnew->next=plist->head->next;
plist->head->next->prev=pnew;

(plist->count)++;
return 1;

}

//出栈(在双向链表的头部删除一个元素)
//失败，返回0;成功，返回1
int StackPop(List *plist,item *pitem)
{
struct node *pde1;
if(StackIsEmpty(plist))
return 0;

pde1=plist->head->next;
*pitem=pde1->item;
pde1->next->prev=plist->head;// 改变下一个节点的前向指针
plist->head->next=pde1->next;
free(pde1);//释放内存
(plist->count)--;

return 1;

}

//队列初始化(和栈的初始化的一样的)
int QueueInit(List *plist,int length)
{
return StackInit(plist,length);
}

//添加元素到队尾
int EnQueue(List *plist,Item item)
{
struct node *pdel;
if(StackIsFull(plist))//若队列为满，返回0
return 0;
pde1=(struct node*)malloc(sizeof(struct node));
if(pde1==0)
return 0;

pde1->item=item;//待插入的元素item
pde1->next=plist->head;
plist->head->prev=pde1;

(plist->count)++;
return 1;
}

// 从队头删除元素
int DeQueue(List *plist,Item *pitem)
{
return StackPop(plist,pitem);
}