数据结构--栈和队列（C语言）

        最近在学习数据结构的路上又学到了新的数据结构，那就是栈和队列，这两个在我理解就是就是附加了更多条件的线性表，下面我们来介绍这两种新的数据结构。

        首先是栈，数据结构的基础功能就是增删查改，在栈里面没有改这个操作，增在栈里面叫做压栈/入栈，删，就是出栈，查也是出栈，但是它会返回那个出栈的数据。而且就是栈的规定就是，数据只能从栈顶进入或者出去，遵循先进后出的规则。举个例子：假如我们有一组数据1，2，3，4，5，6按顺序只进行压栈操作，那么我们在栈里面看到的就是图一，入栈出栈的顺序不同，最后导致出栈的数据顺序也不同，如果按图一出栈的话，数据顺序就是6，5，4，3，2，1。但是如果我们先把1，2，3压栈后在出栈一次，再把4，5，6按顺序压栈，最后将所有数据出栈，那我们会得到的数据顺序是，3，6，5，4，2，1。所以只按顺序进行压栈操作的话，出来的数据顺序不一定是原数据顺序的逆序。

         下面我们来实现一下栈，我们可以发现他只会在栈顶进行数据的操作，现在我们可以有两种方法来实现它，一种是链表，需要用一个指针来维护尾节点也就是栈顶，还有一种是顺序表的方法，需要用两个变量来维护顺序表的数据尾（栈顶），以及顺序表数组的容量来做一个动态栈。如果用链表的话，我们不需要考虑扩容的问题，但是每次找尾节点会很耗费时间，用顺序表入栈出栈很简便，但需要考虑扩容的问题，不难发现顺序表是我们的最佳选择。

        顺序表实现栈代码如下：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

void StackInit(Stack* ps)
{
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = data;
	ps->top++;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}

int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

void StackDestroy(Stack* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

        还有就是线性表，它与栈相似，但是它遵循先进先出的规则，头出尾进，放入拿出数据叫入/出队列，我们像上面压栈的方法对队列进行一样的操作可以发现，不管入队列出队列的顺序如何，插入的数据顺序与出队列的数据顺序始终一致。通过分析，队列的实现用链表会更好一点，如果使用顺序表的话，每次出队列，都需要将数据挪动一遍。而列表只需要进行结点的删除就行。而链表需要使用头尾两个指针来维护链表。

        下面是链表实现队列的代码，代码如下：

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

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

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

void QueueInit(Queue* q)
{
	assert(q);

	q->_front = NULL;
	q->_rear = NULL;
}

void QueuePush(Queue* q, QDataType data)
{
	assert(q);

	QNode* NewData = (QNode*)malloc(sizeof(QNode));
	if (NewData == NULL)
	{
		perror("malloc fail");
		return;
	}
	NewData->data = data;
	NewData->next = NULL;
	if (q->_front == NULL)
	{
		q->_front = NewData;
		q->_rear = NewData;
	}
	else
	{
		q->_rear->next = NewData;
		q->_rear = NewData;
	}
}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	if (q->_front->next == NULL)
	{
		free(q->_front);
		q->_front = NULL;
		q->_rear = NULL;
	}
	else
	{
		QNode* cur = q->_front;
		q->_front = q->_front->next;
		free(cur);
	}
}

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->_front->data;
}

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->_rear->data;
}

int QueueSize(Queue* q)
{
	assert(q);

	QNode* cur = q->_front;
	int count = 0;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

int QueueEmpty(Queue* q)
{
	assert(q);

	return q->_front == NULL;
}

void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->_front;
	while (cur != NULL)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->_front = NULL;
	q->_rear = NULL;
}

         以上就是，我对栈和队列的认识，如果有什么不对的地方，请指正。