栈和队列的实现

在线性排序中，有许许多多排序方法，栈和队列就是其中的典型例子。

在我们日常的生活中，也有许许多多跟栈和队列大同小异的例子。例如在食堂打饭的时候，来得早的同学总是能先打到饭，就是典型的队列排列的方法；而栈呢，就想我们小时候玩的叠罗汉，只有最上面的同学下来后，下面的人才能陆陆续续的起来。

而在数据结构中，栈和队列恰巧是利用了这两个性质。栈：先入后出。队列：先入先出。

接下来我们就看看如何实现栈和队列。

首先来看栈的实现。栈的先入后出的结构，我们使用简单的顺序表就可以了。

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps)
{
	ps->a = (STDataType*)malloc(sizeof(STDataType)*10);
	if (ps->a == NULL)
		perror("malloc fail");
	ps->top = 0;
	ps->capacity = 10;
	ps->size = 0;
}


// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	if (ps->capacity == ps->size)
		ps->a = (STDataType*)realloc(ps->a, sizeof(STDataType) * (ps->capacity+2));
	if (ps->a == NULL)
		perror("realloc fail");


	ps->a[ps->size] = data;
	ps->size++;
	ps->top = data;
}


// 出栈 
void StackPop(Stack* ps)
{
	assert(ps->size!=0);


	ps->size--;
	ps->top = ps->a[ps->size];
}


// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps->capacity != 0);
	return ps->a[ps->size];
}


// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps->capacity != 0);
	return ps->size;
}


// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	if (ps->size == 0)
		return 1;
	else
		return 0;
}


// 销毁栈 
void StackDestroy(Stack* ps)
{
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
	ps->size = 0;
}

但是对于队列，他要求的是先入先出，那就跟头删有关系，为了把时间复杂度降到最小，我们就可以选择用单链表来实现。

// 链式结构：表示队列 
typedef struct QListNode 
{ 
	struct QListNode* _next; 
	QDataType _data; 
}QNode; 

// 队列的结构 
typedef struct Queue 
{ 
	QNode* _front; 
	QNode* _rear; 
}Queue; 


// 初始化队列 
void QueueInit(Queue* q)
{
	QNode* NewNode = (QNode*)malloc(sizeof(QNode));
	q->front = q->rear = NewNode;
	q->front->next = NULL;
}


// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* NewNode = (QNode*)malloc(sizeof(QNode));
	NewNode->next = NULL;


	q->rear->next = NewNode;
	NewNode->data = data;
	q->rear = NewNode;


}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->front->next);


	QNode* del = q->front->next;
	q->front->next = q->front->next->next;
	free(del);


}


// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->front->next);


	return q->front->next->data;
}


// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->rear);


	return q->rear->data;
}


// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	QNode* cur = q->front->next;
	int count = 1;


	while (cur != q->rear)
	{
		cur = cur->next;
		count++;
	}


	return count;
}


// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	if (q->front->next == NULL)
		return 1;
	else
		return 0;
}


// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front->next;
	QNode* del = cur;
	while (cur != q->rear)
	{
		cur = cur->next;
		free(del);
		del = cur;
	}
	free(cur);
	free(q->front);
}

以上就是栈和队列的实现，希望能对大家有所帮助。