实现栈和队列

 1：实现栈和队列 

typedef int DataType; 

typedef struct Stack 
{ 
DataType* _array; 
size_t _top; //栈顶 
size_t _end; 
}Stack; 

// 栈的实现接口 
void StackInit(Stack* s); 
void StackPush(Stack* s, DataType x); 
void StackPop(Stack* s); 
DataType StackTop(Stack* s); 
size_t StackSize(Stack* s); 
int StackEmpty(Stack* s); 

typedef int DataType; 

typedef struct QueueNode 
{ 
DataType _data; 
struct QueueNode* _next; 
}QueueNode; 

typedef struct Queue 
{ 
QueueNode* _head; 
QueueNode* _tail; 
}Queue; 

void QueueInit(Queue* q); 
void QueuePush(Queue* q, DataType x); 
void QueuePop(Queue* q); 
DataType QueueFront(Queue* q); 
DataType QueueBack(Queue* q); 
size_t QueueSize(Queue* q); 
int QueueEmpty(Queue* q);

#include"stack.h"
#define STACKSIZE 5
// 栈的实现接口 
void StackInit(Stack* s)
{
	assert(s);
	s->_array = (DataType*)calloc(STACKSIZE, sizeof(DataType));
	s->_top = STACKSIZE ;
	s->_end = STACKSIZE ;
}

void StackPush(Stack* s, DataType x)
{
	assert(s);
	//栈溢出
	if (s->_top == 0)
	{
		printf("栈满\n");
		return;
	}
	s->_top--;
	s->_array[s->_top] = x;
}

void StackPop(Stack* s)
{
	assert(s);
	if (s->_top == s->_end)
	{
		printf("栈为空\n");
		return;
	}
	s->_top++;
}

DataType StackTop(Stack* s)
{
	assert(s);
	return (s->_array[s->_top]);
}

size_t StackSize(Stack* s)
{
	assert(s);
	return (s->_end - (s->_top));
}

int StackEmpty(Stack* s)
{
	assert(s);
	return (s->_top == s->_end);
}

void PrintStack(Stack* s)
{

	size_t i;
	assert(s);
	for (i = s->_top; i < s->_end; i++)
		printf("%d ", s->_array[i]);
	printf("\n");
}

void QueueInit(Queue* q)
{
	assert(q);
	q->_head = NULL;
	q->_tail = NULL;
}

QueueNode* BuyNode(DataType d)
{
	QueueNode* tmp = (QueueNode*)malloc(sizeof(QueueNode));
	if (tmp == NULL)
		exit(0);
	tmp->_data = d;
	tmp->_next = NULL;
	return tmp;
}

void QueuePush(Queue* q, DataType x)
{
	QueueNode* tmp = BuyNode(x);
	assert(q);
	if (q->_head == NULL)
	{
		q->_head = tmp;
		q->_tail = tmp;
	}
	else
	{
		q->_tail->_next=tmp ;
		q->_tail = tmp;
	}
}

void QueuePop(Queue* q)
{
	QueueNode* del;
	assert(q);
	if (q->_head == NULL)
	{
		return;
	}
	//剩一个结点
	else if (q->_head->_next == NULL)
	{
		free(q->_tail);
		q->_tail = NULL;
		q->_head = NULL;
	}
	else
	{
		del = q->_head;
		q->_head = q->_head->_next;
		free(del);
		del = NULL;
	}
}

DataType QueueFront(Queue* q)
{
	assert(q);
	if (q->_head == NULL)
	{
		printf("队列空\n");
		return 0;
	}
	return q->_head->_data;
}
DataType QueueBack(Queue* q)
{
	assert(q);
	if (q->_tail == NULL)
	{
		printf("队列空\n");
		return 0;
	}
	return q->_tail->_data;
}
size_t QueueSize(Queue* q)
{
	QueueNode* cur = q->_head;
	size_t ret=0;
	assert(q);
	while (cur != NULL)
	{
		ret++;
		cur = cur->_next;
	}
	return ret;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return (q->_head == NULL);
}

void PrintfQueue(Queue* q)
{
	QueueNode* cur = q->_head;
	assert(q);
	while (cur != NULL)
	{
		printf("%d ",cur->_data);
		cur = cur->_next;
	}
	printf("\n");

}