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

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

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

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

#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);
}