数据结构-栈、队列篇

halooy

已于 2024-03-12 15:17:05 修改

阅读量30

点赞数

分类专栏： C/C++ 文章标签：数据结构

于 2023-08-30 14:02:02 首次发布

本文链接：https://blog.csdn.net/m0_49619206/article/details/132451772

版权

C/C++ 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

文章介绍了栈和队列的基本概念，重点阐述了顺序表和链表在实现这两种数据结构时的操作，包括顺序表的pushBack/PopBack（O(n)），链表的尾插和头删（单链表头删O(n)，尾插O(1)；含有尾指针的单链表头删和尾插均为O(1)）。

摘要由CSDN通过智能技术生成

栈：线性表，后进先出

实现：顺序表，链表
常用实现：顺序表 pushBack -->入栈 popBack --> 出栈

队列：线性表，先进先出

入队：尾插
出队：头删
实现：顺序表，链表
顺序表：尾插O(1) 头删O(n)
链表：单链表，尾插O(n)，头删O(1) 含有尾指针的单链表，尾插O(1)，头删O(1)
常用实现：含有尾指针的单链表

	以下为栈实现代码：

//顺序表实现栈
typedef int Type;

typedef struct Stack
{
	Type* _array;
	size_t _size;
	size_t _capacity;
}Stack;

void stackInit(Stack* st, size_t n)
{
	st->_array = (Type*)malloc(sizeof(Type) * n);
	st->_capacity = n;
	st->_size = 0;
}

void stackPush(Stack* st, Type data)
{
	//检查容量
	if (st->_size == st->_capacity)
	{
		st->_capacity *= 2;
		st->_array = (Type*)realloc(st->_array, st->_capacity * sizeof(Type));
	}
	//尾插
	st->_array[st->_size++] = data;
}

void stackPop(Stack* st)
{
	//尾删
	if (st->_size)
		--st->_size;
}
Type stackTop(Stack* st)
{
	return st->_array[st->_size - 1];
}

size_t stackSize(Stack* st)
{
	return st->_size;
}
int stackEmpty(Stack* st)
{
	if (st->_size == 0)
		return 1;
	return 0;
}

void stackDestory(Stack* st)
{
	free(st->_array);
	st->_array = NULL;
	st->_size = st->_capacity = 0;
}

	以下为队列实现代码：

//含有尾指针的单链表实现

typedef int QDataType;

//定义结点
typedef struct QNode
{
	struct QNode* _next;
	QDataType _data;
}QNode;

//定义队列
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int _size;
}Queue;

//初始化
void queueInit(Queue* q)
{
	//初始化空队列
	q->_front = q->_rear = NULL;
	q->_size = 0;
}

//创建结点
QNode* creatNode(QDataType data)
{
	QNode* node = (QNode*)malloc(sizeof(QNode));
	node->_data = data;
	node->_next = NULL;
	return node;
}

//入队列
void queuePush(Queue* q, QDataType data)
{
	QNode* node = creatNode(data);
	//空队列
	if (q->_front == NULL)
		q->_front = q->_rear = node;
	else 
	{
		q->_rear->_next = node;
		q->_rear = node;
	}
	++q->_size;
}

//队头出队
void queuePop(Queue* q)
{
	if (q->_front)
	{
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
		//删除之后是否为空表
		if (q->_front == NULL)
			q->_rear = NULL;
	}
	--q->_size;
}

//获取队头元素
QDataType queueFront(Queue* q)
{
	return q->_front->_data;
}

//获取队尾元素
QDataType queueBack(Queue* q)
{
	return q->_rear->_data;
}

int queueSize(Queue* q)
{
	int num = 0;
	QNode* cur = q->_front;
	while (cur)
	{
		++num;
		cur = cur->_next;
	}
	return num;
	//写法二
	//return q->_size;
}

//判断是否为空
int queueEmpty(Queue* q)
{
	if (q->_front == NULL)
		return 1;
	return 0;
}

//清空队列
void queueDestory(Queue* q)
{
	QNode* cur = q->_front;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	q->_front = q->_rear = NULL;
	q->_size = 0;
}