数据结构：栈和队列

最新推荐文章于 2024-09-10 20:37:54 发布

二十五·夜

最新推荐文章于 2024-09-10 20:37:54 发布

阅读量250

点赞数 4

文章标签：数据结构

本文链接：https://blog.csdn.net/2302_81442125/article/details/140692774

版权

1、栈

1.1栈的概念

栈：是一种特殊的线性表，只允许在固定的一端进行插入或者删除。进行数据的插入和删除的一端为栈顶，另一端为栈低。栈中的元素遵守后进先出的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈，出数据也在栈顶。

1.2栈的实现

栈的实现一般使用数组或者链表，相对而言数组的结构实现更优一些，数组尾插时代价较小。

Stack.h文件：

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

typedef int STDataType;
typedef struct Stack
{
	STDataType* _arr;
	int _top;
	int _capacity;
}Stack;
//初始化
void StackInit(Stack*ps);
//销毁
void StackDestroy(Stack*ps);
//入栈
void StackPush(Stack* ps, STDataType x);
//出栈
void StackPop(Stack* ps);
//取栈顶元素
STDataType StackTop(Stack* ps);
//取栈的有效个数
int StackSize(Stack* ps);
//检查栈是不是为空
bool StackEmpty(Stack* ps);

Stack.c文件：

#include"Stack.h"
void StackInit(Stack* ps)
{
	ps->_arr = NULL;
	ps->_top = ps->_capacity = 0;//_top指向栈顶元素的下一个	
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_arr);
	ps->_arr = NULL;
	ps->_capacity = ps->_top = 0;
}

void StackCheckCapacity(Stack*ps)
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		int newcapacity = ps->_capacity == 0 ? 4 : 2 * ps->_capacity;
		STDataType* arr = (STDataType*)malloc(sizeof(STDataType)*newcapacity);
		if (arr == NULL)
		{
			perror("malloc fail");
			exit(1);
		}
		ps->_arr = arr;
		ps->_capacity = newcapacity;
	}
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	StackCheckCapacity(ps);
	ps->_arr[ps->_top++] = x;
}

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

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	return ps->_arr[ps->_top - 1];
}

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

bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0;
}

test.c文件：

#include"Stack.h"
void test()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	printf("%d\n", StackTop(&s));
	StackPop(&s);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackDestroy(&s);
}
int main()
{
	test();

	return 0;
}

2、队列

2.1队列的概念

队列：只允许在一端插入数据，在另一端删除数据，队列具有先进先出的原则

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

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

2.2队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

Queue.h:

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int QLDataType;
typedef struct QListNode
{
	QLDataType val;
	struct QListNode* next;
}QL;
typedef struct QueueNode
{
	QL* head;
	QL* rear;
	int size;
}Queue;
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//队尾插入
void QueuePush(Queue*pq,QLDataType x);
//队头删除
void QueuePop(Queue*pq);
//取队头数据
QLDataType QueueFront(Queue* pq);
//取队尾数据
QLDataType QueueBack(Queue* pq);
//队列节点个数
int QueueSize(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);
QL* QLCreate(QLDataType x);

Queue.c:

#include"Queue.h"
//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->rear = NULL;
	pq->size = 0;
}
//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QL* pcur = pq->head;
	while (pcur)
	{
		QL* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->head=pq->rear=NULL;
	pq->size = 0;
}
//队尾插入
QL* QLCreate(QLDataType x)
{
	QL* tmp = (QL*)malloc(sizeof(QL));
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	tmp->val = x;
	tmp->next = NULL;
	return tmp;
}
void QueuePush(Queue* pq, QLDataType x)
{
	if (pq->rear==NULL)
	{
		pq->head = pq->rear = QLCreate(x);
	}
	else
	{
		pq->rear->next = QLCreate(x);
		pq->rear = QLCreate(x);
	}
	pq->size++;
}
//队头删除
void QueuePop(Queue* pq)
{
	assert(pq && pq->size > 0);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->rear == NULL;
	}
	else
	{
		QL* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
//取队头数据
QLDataType QueueFront(Queue* pq)
{
	assert(pq && pq->size > 0);
	return pq->head->val;
}
//取队尾数据
QLDataType QueueBack(Queue* pq)
{
	assert(pq && pq->size > 0);
	return pq->rear->val;
}
//队列节点个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

test.c:

#include"Queue.h"
void test()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	printf("%d\n", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	printf("%d\n", QueueFront(&q));
	printf("%d\n", QueueSize(&q));
}
int main()
{
	test();
	return 0;
}