数据结构【栈和队列】

1. 什么是栈，栈有什么特性？

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一段称为栈顶，另一端称为栈底。栈的数据元素遵守后进先出（LIFO）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，插入数据在栈顶。
出栈：栈的删除操作叫做出栈，删除数据也在栈顶。

2. 用C语言实现一个动态栈

typedef int SDataType;

typedef struct Stack{
	SDataType* _array;
	int _capacity;       //栈的容量
	int _size;           //栈中的有效元素个数，代表栈顶位置
}Stack;
//栈的初始化
void StackInit(Stack* ps) {
	assert(ps);
	ps->_array = (SDataType*)malloc(sizeof(SDataType)*3);
	if (NULL == ps->_array) {
		assert(0);
		return;
	}
	ps->_capacity = 3;
	ps->_size = 0;
}

//检查容量及扩容
void CheckCapacity(Stack* ps) {
	assert(ps);
	if (ps->_size == ps->_capacity) {
		int newCapacity = ps->_capacity*2;
		SDataType* pTemp =(SDataType*)malloc(sizeof(SDataType)*newCapacity);
		if (NULL == pTemp) {
			assert(0);
			return;
		}
		for (int i = 0; i < ps->_size; i++) {
			pTemp[i] = ps->_array[i];
		}
		free(ps->_array);
		ps->_array = pTemp;
		ps->_capacity = newCapacity;
	}
}

//插入
void StackPush(Stack* ps, SDataType data) {
	CheckCapacity(ps);
	ps->_array[ps->_size] = data;
	ps->_size += 1;
}

//删除
void StackPop(Stack* ps) {
	assert(ps);
	if (StackEmpty(ps)) {
		return;
	}
	ps->_size -= 1;
}

//获取栈顶元素
SDataType StackTop(Stack* ps) {
	assert(ps);
	return ps->_array[ps->_size - 1];
}

//获取栈中的元素个数
int StackSize(Stack* ps) {
	assert(ps);
	return ps->_size;
}

//栈的判空
int StackEmpty(Stack* ps) {
	assert(ps);
	return 0 == ps->_size;
}

//栈的销毁
void StackDestroy(Stack* ps) {
	assert(ps);
	if (ps->_array) {
		free(ps->_array);
		ps->_capacity = 0;
		ps->_size = 0; 
	}
}

测试函数

#include<malloc.h>
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

void TestStack() {
	Stack s;
	StackInit(&s);

	StackPush(&s, 1);
	StackPush(&s, 2);	
	StackPush(&s, 3);
	printf("size=%d\n", StackSize(&s));
	printf("top=%d\n", StackTop(&s));

	StackPop(&s);
	printf("size=%d\n", StackSize(&s));
	printf("top=%d\n", StackTop(&s));


	StackDestroy(&s);
}


int main() {
	TestStack();
	system("pause");
	return;
}

3. 栈和程序运行时的栈区有什么区别？

我们这里的栈是一种特殊的数据结构
程序运行时的栈区是一段存储空间
二者不是同一个东西

4.什么是队列，队列有什么特性？栈和队列有什么区别？

队列是一种特殊的数据结构，队列只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出（FIFO）的特性。进行插入操作的一端称为队尾，进行删除操作的一算称为队头。

栈	队列
在一端插入和删除数据，后进先出（LIFO）	在一端插入数据，在另一端删除数据，先进先出（FIFO）
只能从顶部取数据，遍历数据需要开辟临时空间来保证数据便利前后的一致性	基于地址指针进行遍历，无需开辟新空间，遍历速度快

5. 用C语言实现一个队列

typedef int QDataType;

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

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

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

void QueueInit(Queue* q) {
	assert(q);
	q->_back = q->_back = NULL;
}
//插入数据
void QueuePush(Queue* q, QDataType data) {
	assert(q);
	QNode* pNewNode = BuyQueueNode(data);
	if (QueueEmpty(q)) {
		q->_front = q->_back = pNewNode;
	}
	else {
		q->_back->_pNext = pNewNode;
		q->_back = pNewNode;
	}
}
//删除数据
void QueuePop(Queue* q) {
	if (QueueEmpty(q)) {
		return;
	}
	QNode* pDelNode = q->_front;
	if (NULL==pDelNode->_pNext) {
		q->_front = q->_back= NULL;
	}
	else {
		q->_front = pDelNode->_pNext;
	}
	free(pDelNode);
}
//获取队列头部元素
QDataType QueueFront(Queue* q) {
	assert(q);
	return q->_front->_data
}
//获取队列尾部元素
QDataType QueueBack(Queue* q) {
	assert(q);
	return q->_back->_data;
}
//获取队列有效元素个数
int QueueSize(Queue* q) {
	int count = 0;
	QNode* pCur = q->_front;
	while (pCur) {
		count++;
		pCur = pCur->_pNext;
	}
	return count;
}
//判断队列是否为空
int QueueEmpty(Queue* q) {
	assert(q);
	return NULL == q->_front;
}
//销毁队列
void QueueDestroy(Queue* q) {
	QNode* pCur = q->_front;
	while (pCur) {
		q->_front = pCur->_pNext;
		free(pCur);
		pCur = q->_front;
	}
	q->_front = q->_back = NULL;
}

测试队列函数

#include<stdio.h>
#include<malloc.h>
#include<assert.h>
#include<stdlib.h>

void TestQueue() {
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	printf("front=%d\n", QueueFront(&q));
	printf("back=%d\n", QueueBack(&q));
	printf("size=%d\n", QueueSize(&q));
	QueuePop(&q);
	printf("front=%d\n", QueueFront(&q));
	printf("back=%d\n", QueueBack(&q));
	printf("size=%d\n", QueueSize(&q));
	QueueDestroy(&q);


}

int main() {
	TestQueue();
	system("pause");
	return 0;
}