C语言实现栈和队列

最新推荐文章于 2024-07-25 11:43:17 发布

(int*) nightfall

最新推荐文章于 2024-07-25 11:43:17 发布

阅读量50

点赞数 5

文章标签：数据结构

本文链接：https://blog.csdn.net/sxc1357sxc/article/details/133620500

版权

栈

栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数

据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last

In First Out）的原则。

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

栈的实现

！！！栈用顺序表实现

栈的结构体类型声明

typedef int stackdate;
typedef struct stack
{
	stackdate* date;
	int top;
	int capatity;
}st;

其中date是栈里存放数据的位置，其为动态开辟内存空间的数组；

top为栈顶位置，主要是用来数据的入栈和出栈；

capatity为栈的数据容量；

栈的初始化

只需都初始化为空和0即可；

//栈的初始化：
void stinit(st* ps)
{
	assert(ps);
	ps->date = NULL;
	ps->top = 0;
	ps->capatity = 0;
}

栈的销毁

释放动态开辟的内存空间，然后栈顶位置和容量都置为0即可；

//栈的销毁
void stdestory(st* ps)
{
	assert(ps);
	free(ps->date);
	ps->date = NULL;

	ps->top = 0;
	ps->capatity = 0;

}

数据压栈

将数据存入栈的时候首先要检查栈空间是否已满；如果空间已满则需要扩容；

然后将数据存入即可；

//压栈：
void stpush(st* ps, stackdate x)
{
	assert(ps);

	//判断栈数据容量是否满了
	if (ps->top == ps->capatity)
	{
		int newcapatity = ps->capatity == 0 ? 4 : ps->capatity * 2;

		stackdate* tmp = (stackdate*)realloc(ps->date, sizeof(stackdate) * (ps->capatity));
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}

		ps->date = tmp;
		ps->capatity = newcapatity;
	}

	//存入数据；
	ps->date[ps->top] = x;
	ps->top++;

}

数据出栈

只需要栈顶的位置向后移动即可；


//出栈：
void stpop(st* ps)
{
	assert(ps);

	assert(ps->top > 0);

	ps->top--;
}

栈内的元素个数

直接返回栈顶的位置即可；

//栈内的元素个数：
int stsize(st* ps)
{
	assert(ps);

	return ps->top;
}

清空栈

只需要将栈的栈顶位置top置为0即可；

//清空栈：
void stempty(st* ps)
{
	assert(ps);

	ps->top = 0;
}

返回栈顶元素

只需要直接将栈顶后的那个元素返回即可；

//拿出栈顶元素；
stackdate sttop(st* ps)
{
	assert(ps);
	assert(ps->top > 0);

	return ps->date[ps->top-1];
}

判断是否为空栈

top==0就是空栈，否则就是非空；

//判断是否为空栈：
bool emptyst(st* ps)
{
	assert(ps);

	return ps->top == 0;
}

队列

队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性

表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为 队尾出队列：

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

队列的实现

！！！队列用链表实现；

队列节点类型声明

结点里有存放的数据，和指向下个结点的指针；

//队列节点类型声明：
typedef int quenedate;
typedef struct qnode
{
	quenedate date;
	struct qnode* next;
}qnode;

队列类型声明

队列实际上是一条链表，包含首位的结点指针，和链表的结点个数；

//队列类型声明：
typedef struct quene
{
	struct qnode* head;
	struct qnode* tail;
	int size;
	
}quene;

队列的初始化

首位指针都为空，结点个数也为0；

//队列的初始化：
void queuelint(quene* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}

队尾入队列

首先创建结点，然后将结点连接到队列队尾即可；

// 队尾入队列 
void QueuePush(quene* q, quenedate data)
{
	assert(q);

	//创建结点；
	qnode* newnode = (qnode*)malloc(sizeof(qnode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}

	newnode->date = data;
	newnode->next = NULL;

	//将结点连接到队列上
	if (q->tail == NULL)
	{
		q->head = q->tail = newnode;
		q->size++;

	}
	else
	{
		q->tail->next = newnode;
		q->size++;
		q->tail = q->tail->next;
	}
}

判断队列是否为空；

只需要判断size是否为0即可；


bool QueueEmpty(quene* q)
{
	assert(q);
	
	return q->size == 0;
}

队头出队列

只需要将队头的结点释放掉即可；释放的时候有两种情况，队列只有一个结点或者队列里有不止一个结点；

// 队头出队列 
void QueuePop(quene* q)
{
	assert(q);

	//断言队列不能为空；
	assert(!QueueEmpty(q));

	//队列里只有一个结点；
	if (q->head ->next=NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
		q->size--;
	}
	//队列里不止有一个结点；
	else
	{
		qnode* tmp = q->head;
		q->head = q->head->next;
		free(tmp);
		tmp = NULL;
		q->size--;
	}

}

获取队列头部元素

直接返回队列头结点的数据即可；

// 获取队列头部元素 
quenedate QueueFront(quene* q)
{
	assert(q);

	//断言队列不能为空；
	assert(!QueueEmpty(q));

	return q->head->date;
}

获取队列队尾元素

直接返回队列尾结点的数据即可；

// 获取队列队尾元素 
quenedate QueueBack(quene* q)
{
	assert(q);

	//断言队列不能为空；
	assert(!QueueEmpty(q));

	return q->tail->date;
}

获取队列中元素个数

直接返回size即可；

// 获取队列中元素个数 
int QueueSize(quene* q)
{
	assert(q);
	return q->size;
}

销毁队列

如果队列里有结点释放空间；如果没有结点直接返回即可；

// 销毁队列 
void QueueDestroy(quene* q)
{
	assert(q);

	if (QueueEmpty(q))//队列里没有结点
	{
		q->head = q->tail = NULL;
		q->size = 0;
		return;
	}

	//队列里有结点；
	qnode* cur = q->head;
	while (cur)
	{
		qnode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	q->head = q->tail = NULL;
	q->size = 0;	
}