栈和队列的创建

最新推荐文章于 2024-06-12 08:23:53 发布

chunlalala

最新推荐文章于 2024-06-12 08:23:53 发布

阅读量739

点赞数 4

文章标签：数据结构 c语言

本文链接：https://blog.youkuaiyun.com/chunlalala/article/details/123593465

版权

本文详细介绍了栈和队列这两种基本数据结构的定义及其在计算机科学中的实现。栈是一种后进先出（LIFO）的数据结构，常使用顺序表实现，提供了初始化、入栈、出栈和判断栈空的功能。队列则是先进先出（FIFO）的数据结构，通常用链表实现，包括队头入队、队尾出队、获取队尾元素和判断队列空的方法。这些基础数据结构在算法和程序设计中扮演着重要角色。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

栈和队列的定义

栈是只允许在固定的一端进行插入和删除元素操作的线性表，进行插入和删除的一端称作栈顶，另一端为栈底。
栈通常使用顺序表进行实现，便于在栈顶top进行插入删除操作
在这里插入图片描述

typedef struct stack
{
	SDataType * array;
	int capacity;//栈的容量
	int top;//栈顶下标
}Stack;

队列是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾rear
出队列：进行删除操作的一端称为队头front
在这里插入图片描述

typedef struct node
{
	QDataType data;
	struct node* next;
}node;
typedef struct Queue
{
	node* front;
	node* rear;
}Queue;

在这里插入图片描述

栈的初始化

void StackInit(Stack* st,int capacity)
{
	assert(st);
	st->array = (SDataType*)malloc(sizeof(SDataType)*capacity);
	if (st->array)
	{
		st->capacity = capacity;
		st->top = 0;
	}
}

入栈

Stack *Capacity(Stack* st)//对栈进行扩容
{
	int newcapacity = st->capacity * 2;
	SDataType* temp = (SDataType*)malloc(sizeof(SDataType) * newcapacity);//申请一个二倍大的空间
	if (temp == NULL)
		return NULL;
	memcpy(temp, st->array, sizeof(SDataType) * st->capacity);//将旧栈中的数据拷贝进新栈
	free(st->array);
	st->array = temp;
	st->capacity = newcapacity;
	return st;
}
void StackPush(Stack* st,SDataType x)、、入栈
{
    assert(st);
	if (st->capacity == st->top)
		st=Capacity(st);//栈满需对栈进行扩容
	st->array[st->top] = x;
	st->top++;
}

出栈

void StackPop(Stack* st)
{
	if (StackEmpty(st))
		printf("出栈出错");
	st->top--;
}

判断栈空

int StackEmpty(Stack* st)
{
	if (st->top == 0)
		return 1;
	else return 0;
}

销毁栈

void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->capacity = 0;
		ps->top = 0;
	}	
}

初始化队列

队列通常用带头节点的链表进行实现，方便在队头进行删除操作

void QueueInit(Queue* q)
{
	q->front =(node*)malloc(sizeof(node));
	if (q->front)
	{
		q->rear = q->front;
		q->front->next = NULL;
		q->front->data = 0;
	}	
}

队尾入队列

void QueuePush(Queue* q, QDataType data)
{
	node *p = (node*)malloc(sizeof(node));
	if (p == NULL)
		return;
	else {
		p->data = data;
		q->rear->next = p;
		q->rear = p;
		q->rear->next = NULL;
	}	
}

队头出队列

QDataType QueuePop(Queue* q)
{
	assert(q);
	QDataType ret = q->front->next->data;
	if (!QueueEmpty(q))
	{
		node* p = q->front->next;
		q->front->next = p->next;
		//队列中只有一个元素
		if (p == q->rear)
			q->rear = q->front;
		free(p);
	}
	return ret;
}

获取队列队尾元素

QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->rear->data;
}

判断队列空

int QueueEmpty(Queue* q)
{
	assert(q);
	if (q->front == q->rear)
		return 1;
	else return 0;
}

销毁队列

void QueueDestroy(Queue* q)
{
	assert(q);
	node* p = q->front->next;
	while (p)
	{
		q->front->next = p->next;
		free(p);//将队列中的每个节点释放
		p = q->front->next;
	}
	free(q->front);
	q->front = q->rear = NULL;
}