栈和队列

栈

栈: 一种特殊的线性表,其只允许在固定的一端插入和删除元素. 进行数据插入和删除操作的一端称为栈顶. 另一端称为栈底. 栈中的数据元素遵守先进后出LIFO原则.

压栈: 栈的插入操作叫做进栈/压栈/入栈, 入数据在栈顶

出栈: 栈的删除操作叫出栈, 出数据叶子栈顶

栈的实现

头文件Stack.h

#pragma once
typedef int STDataType;

typedef struct Stack {
	STDataType* _array;
	int _capacity;
	int _size;	
}Stack;

void StackInit(Stack* ps);
void StackPush(Stack* ps, STDataType data);
void StackPop(Stack* ps);
int StackSize(Stack* ps);
int StackEmpty(Stack* ps);
void StackDestory(Stack* ps);
void CheckCapacity(Stack* ps);
STDataType StackTop(Stack* ps);

源文件Stack.c

#include "Stack.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

void CheckCapacity(Stack* ps) {
	assert(ps);
	if (ps->_size == ps->_capacity) {
		int newCapacity = ps->_capacity * 2;
		STDataType* pTemp = (STDataType*)malloc(sizeof(STDataType) * newCapacity);
		if (pTemp == NULL) {
			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 StackInit(Stack* ps) {
	assert(ps);
	ps->_array = (STDataType*)malloc(sizeof(STDataType) * 3);
	if (ps->_array == NULL) {
		assert(0);
		return;
	}
	ps->_capacity = 3;
	ps->_size = 0;
}

void StackPush(Stack* ps, STDataType data) {
	CheckCapacity(ps);
	ps->_array[ps->_size++] = data;
}

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

STDataType 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 StackDestory(Stack* ps) {
	assert(ps);
	if (ps->_array) {
		free(ps->_array);
		ps->_capacity = 0;
		ps->_size = 0;
	}
}

栈和程序运行时的栈区有什么区别?

栈: 栈是一种先进后出性质的数据结构.

栈区: 由编译器自动分配释放,存放函数的参数值,局部变量值等

为什么将递归程序转化成循环时需要用到栈?

每次调用函数时,会把当前函数的局部变量和返回地址都压栈保存起来.当函数调用结束返回时,再把局部变量从栈里弹出来.而递归的核心就是重复的函数调用,如果要转换成循环,就可能需要自己实现栈的数据结构用来保存一些状态变量

队列

只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO的特点

入队列: 进行插入操作的一端称为队尾

出队列: 进行删除操作的一端称为对头

队列的实现

头文件Queue.h

#pragma once
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);
void QueuePop(Queue* q);
QDatatype QueueFront(Queue* q);
QDatatype QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestory(Queue* q);

源文件Queue.c

#include "Queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

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

void QueueInit(Queue* q) {
	assert(q);
	q->_front = 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) {
	QNode* pDelNode = NULL;
	if (QueueEmpty(q)) {
		return;
	}
	pDelNode = q->_front;
	if (pDelNode->_pNext == NULL) {
		q->_front = q->_back = NULL;
	}
	else {
		q->_front = pDelNode->_pNext;
	}
	free(pDelNode);
}

QDatatype QueueBack(Queue* q) {
	assert(q);
	return q->_back->_data;
}

QDatatype QueueFront(Queue* q) {
	assert(q);
	return q->_front->_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 q->_front == NULL;
}

void QueueDestory(Queue* q) {
	QNode* pCur = q->_front;
	while (pCur) {
		q->_front = pCur->_pNext;
		free(pCur);
		pCur = q->_front;
	}
	q->_front = q->_back = NULL;
}

栈和队列的区别

1. 栈先进后出, 队列先进先出

2. 插入删除: 栈只能从一端进行插入和删除操作, 而队列从一端进行插入,从另一端进行删除

3. 遍历数据速度不同

4. 应用场景不同: 常见栈的应用场景包括括号问题的求解, 表达式的转换和求值, 函数调用和递归实现, 深度优先搜索遍历等. 常见的队列的应用场景包括计算机系统中各种资源的管理, 消息缓冲器的管理和广度优先搜索遍历等.