队列，栈的理解与例题

^～^558

已于 2023-04-14 19:46:51 修改

阅读量85

点赞数

文章标签：链表数据结构

于 2023-03-21 17:44:38 首次发布

本文链接：https://blog.csdn.net/qq_65722426/article/details/129693407

版权

1.队列与栈的实现

1.1队列的实现

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

直接上代码：

#pragma once
#define QuNodeDataType int 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef struct QuNode
{
	struct QuNode* next;
	QuNodeDataType data;
}QuNode;

typedef struct Queue
{
	QuNode* head;
	QuNode* tail;
	int size;
}Queue;

void QueueInit(Queue* obj);

void QueueDestroy(Queue* obj);

void QueuePush(Queue* obj, QuNodeDataType x);

void QueuePop(Queue* obj);

Queue.c

#include"Queue.h"


void QueueInit(Queue* obj)
{
	assert(obj);

	obj->head = obj->tail = NULL;
	obj->size = 0;
}

void QueueDestroy(Queue* obj)
{
	assert(obj);
	while (obj->head)
	{
		QuNode* cur = obj->head->next;
		free(obj->head);
		obj->head = cur;
	}
	obj->head = obj->tail = NULL;
	obj->size = 0;
}

void QueuePush(Queue* obj, QuNodeDataType x)
{
	assert(obj);
	QuNode* newnode = (QuNode*)malloc(sizeof(QuNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;
	if (obj->head == NULL)
	{
		obj->head = obj->tail = newnode;
	}
	else
	{
		obj->tail->next = newnode;
		obj->tail = newnode;
	}
	obj->size++;
}

void QueuePop(Queue* obj)
{
	assert(obj);
	assert(obj->head);
	if (obj->head->next != NULL)
	{
		QuNode* next = obj->head->next;
		free(obj->head);
		obj->head = next;
		obj->size--;
	}
	else
	{
		free(obj->head);
		obj->head = obj->tail = NULL;
		obj->size--;
	}
}

2.1栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
直接上代码：

Stack.h
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
#define STDataType int
typedef struct stack
{
	STDataType* a;
	int top;
	int capecity;
}ST;

void STDestory(ST* p);
void STInit(ST* p);
void STPush(ST* p,STDataType a);
void STPop(ST* p);
int STSize(ST* p);
bool STEmpty(ST* p);
STDataType STTopData(ST* p);

Stack.c
#include"stack.h"


void STInit(ST* p)
{
	p->a=(STDataType*)malloc(4*sizeof(ST));
	p->capecity = 4;
	p->top = 0;
}


void STDestory(ST* p)
{
	assert(p);
	free(p->a);
	p->a = NULL;
	p->capecity = 0;
	p->top = 0;
}


void STPush(ST* p,STDataType a)
{
	assert(p);
	if (p->top == p->capecity)
	{
		STDataType* temp=(STDataType*)realloc(p,sizeof(p->capecity*2*sizeof(STDataType)));
		if (temp == NULL)
		{
			perror("realloc fail");
			return;
		}
		p->a = temp;
	}
	p->a[p->top] = a;
	p->top++;
}

void STPop(ST* p)
{
	assert(p);
	assert(!STEmpty(p));
	p->top--;
}


int STSize(ST* p)
{
	return p->top;
}


bool STEmpty(ST* p)
{
	assert(p);
	return p->top == 0;
}

STDataType STTopData(ST* p)
{
	assert(p);
	assert(!STEmpty(p));
	return p->a[p->top-1];
}