C语言 栈和队列

1. 什么是栈，栈有什么特性？
   栈,一种特殊的线性表,其只允许在固定的一端进行插入和删除元素的操作.进行数据插入和删除的一端称为栈顶,另一端称为栈底.插入的操作称为入栈/进栈/压栈,删除操作称为出栈,插入和删除的操作都在栈顶.
   栈中的数据遵循后进先出原则(Last In First Out)
2. 用C语言实现一个动态栈
   栈结构以及主要功能

#pragma once
#include <stdio.h>
#include <assert.h>
#include <malloc.h>

#define SIZE 5
typedef int SDataType;
typedef struct Stack {
	SDataType* arr;
	int capaciity;
	int size;
}Stack;

//栈的初始化
void StackInit(Stack* ps);
//入栈
void StackPush(Stack* ps, SDataType data);
//出栈
void StackPop(Stack* ps);
//获取栈顶元素
SDataType StackTop(Stack* ps);
//获取栈中元素个数
int StackSize(Stack* ps);
//判断栈是否为空
int StackEmpty(Stack* ps);
//销毁栈
void StackDestroy(Stack* ps);
//栈空间扩容
void BuySpace(Stack* ps);

栈主要功能的实现:

#include "Stack.h"

void StackInit(Stack* ps) {
	assert(ps);
	ps->arr = (SDataType*)malloc(5 * sizeof(SDataType));
	if (ps->arr == NULL) {
		assert(0);
		return;
	}
	ps->capaciity = 5;
	ps->size = 0;
}

void StackPush(Stack* ps, SDataType data) {
	assert(ps);
	if (ps->capaciity == ps->size) {
		BuySpace(ps);
	}
	ps->arr[ps->size] = data;
	ps->size++;
}

void StackPop(Stack* ps) {
	assert(ps);
	if (ps->size == 0) {
		return;
	}
	ps->size--;
}

SDataType StackTop(Stack* ps) {
	assert(ps);
	if (ps->size == 0) {
		return NULL;
	}
	return ps->arr[ps->size - 1];
}

int StackEmpty(Stack* ps) {
	assert(ps);
	return !ps->size;
}

int StackSize(Stack* ps) {
	assert(ps);
	return ps->size;
}

void StackClear(Stack* ps) {
	assert(ps);
	ps->size = 0;
}

void StackDestroy(Stack* ps) {
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
}

void BuySpace(Stack* ps) {
	assert(ps);
	ps->arr = realloc(ps->arr, 2 * (ps->capaciity) * sizeof(SDataType));
	if (ps->arr == NULL) {
		assert(0);
		return;
	}
	ps->capaciity = 2 * (ps->capaciity);
}

int main() {
	Stack ps;
	StackInit(&ps);
	StackDestroy(&ps);
	return 0;
}

3. 栈和程序运行时的栈区有什么区别？
   栈区：是一块内存空间，由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等
   栈：具有后进先出的数据结构

4. 为什么将递归程序转化成循环时需要用到栈？
   在实现函数调用的时候，系统底层就是用栈来保存函数运行现场的；具体来说，每次调用函数时，会把当前函数的局部变量和返回地址都压栈保存起来，当函数调用结束返回的时候，再把局部变量从栈里弹出来。
   而递归的核心就是重复的函数调用。因此如果要变成非递归，就可能需要自己实现栈数据结构用来保存一些状态变量；这其实就是在模拟函数调用。

5. 什么是队列，队列有什么特性？栈和队列有什么区别？
   队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出特性FIFO(First In First Out)
   入队列：进行插入操作的一端称为队尾
   出队列：进行删除操作的一端称为队头
   栈与队列的相同点：
   1.都是线性结构。
   2.插入操作都是限定在表尾进行。
   3.都可以通过顺序结构和链式结构实现。、
   4.插入与删除的时间复杂度都是O（1），在空间复杂度上两者也一样。
   5.多链栈和多链队列的管理模式可以相同。
   栈与队列的不同点：
   1.删除数据元素的位置不同，栈的删除操作在表尾进行，队列的删除操作在表头进行。
   2.应用场景不同；常见栈的应用场景包括括号问题的求解，表达式的转换和求值，函数调用和递归实现，深度优先搜索遍历等；常见的队列的应用场景包括计算机系统中各种资源的管理，消息缓冲器的管理和广度优先搜索遍历等。
   3.顺序栈能够实现多栈空间共享，而顺序队列不能。

6. 请用C语言实现一个队列
   Queue.h

#pragma once
#include <assert.h>
#include <malloc.h>
#include <stdio.h>

typedef int QDataType;
typedef struct QNode
{
	struct QNode* _pNext;
	QDataType _data;
}QNode;

typedef struct Queue
{
	QNode* _front; // 指向队头元素 
	QNode* _back; // 指向队尾元素 
}Queue;

//队列初始化
void QueueInit(Queue* q);
//队尾插入元素
void QueuePush(Queue* q, QDataType data);
//申请新的节点空间
QNode* BuyQueueNode(QDataType data);
//删除队头元素
void QueuePop(Queue* q);
//查看对头元素
QDataType QueueFront(Queue* q);
//查看队尾元素
QDataType QueueBack(Queue* q);
//查看队中元素个数
int QueueSize(Queue* q);
//查看队列是否为空
int QueueEmpty(Queue* q);
//销毁队列
void QueueDestroy(Queue* q);

#include "Queue.h"

void QueueInit(Queue* q) {
	assert(q);
	q->_back = q->_front = NULL;
}

QNode* BuyQueueNode(QDataType data) {
	QNode* NewNode = (QNode*)malloc(sizeof(QNode));
	if (NewNode == NULL) {
		assert(0);
		return NULL;
	}
	NewNode->_data = data;
	NewNode->_pNext = NULL;
	return NewNode;
}

void QueuePush(Queue* q,QDataType data) {
	assert(q);
	QNode* NewNode = BuyQueueNode(data);
	if (q->_back == NULL) {
		q->_back = NewNode;
		q->_front = NewNode;
	}
	else {
		q->_back->_pNext = NewNode;
		q->_back = q->_back->_pNext;
	}
}

void QueuePop(Queue* q) {
	assert(q);
	if (q->_front == NULL) {
		return;
	}
	QNode* p = q->_front;
	q->_front = q->_front->_pNext;
	free(p);
	p = NULL;
	if (q->_front == NULL) {
		q->_back = NULL;
	}
}

QDataType QueueFront(Queue* q) {
	assert(q);
	if (q->_front == NULL) {
		return 0 - 1;
	}
	return q->_front->_data;
}

QDataType QueueBack(Queue* q) {
	assert(q);
	if (q->_back == NULL) {
		return NULL;
	}
	return q->_back->_data;
}

int QueueSize(Queue* q) {
	assert(q);
	if (q->_front == NULL) {
		return 0;
	}
	int count = 1;
	QNode* p = q->_front;
	while(p != q->_back) {
		p = p->_pNext;
		count++;
	}
	return count;
}

int QueueEmpty(Queue* q) {
	assert(q);
	return !q->_front;
}

void QueueDestroy(Queue* q) {
	assert(q);
	while (q->_front != NULL) {
		QueuePop(q);
	}
}

int main() {
	Queue q;
	QueueInit(&q);
	QueueDestroy(&q);	
}