数据结构栈和队列详解（附详细代码）

一. 栈

 1.栈的特性：

   一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除元素的一端为栈顶，另一端为栈底。栈中的数据元素是后进先出（Last in First Out)的原则。

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

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

   这个Top我们可以初始化任意值，只不过我们一般都是初始化为零，让Top指向栈顶元素的下一位。

2.栈的存储结构：

  

构成栈的每个小空间都有data域（存放数据）和指针域（指向栈底方向直到指向栈底）。

//静态存储
//这里给栈分配空间是由N的值来决定
//若所需空间大于N，则需再次开辟空间
//若N的值远远大于所需空间，则造成空间浪费
#define N 10
typedef struct stack{
	int a[N];
	int top;
};

 

//动态分配
//依据需求随时开辟空间，避免空间浪费
typedef int STDataType;

typedef struct Stack{
	STDataType* a; //存储元素的数组
	int top;      //栈顶
	int capacity;//栈的容量
}ST;

    定长的静态栈结构，实际中一般不实用，所以我们主要实现支持动态增长的栈。

3.栈的实现：

   功能函数：

void STInit(ST* ps);//栈的初始化
void STDestroy(ST* ps);//栈的销毁
void STPush(ST* ps, STDataType x);//压栈
void STPop(ST* ps);//出栈
bool STEmpty(ST* ps);//栈空
STDataType STTop(ST* ps);//取栈顶元素
int STsize(ST* ps);//栈的元素个数

    具体实现：

void STInit(ST* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
	
}

void STPush(ST* ps, STDataType x) 
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);

		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);

	assert( ps->top > 0);

	--ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

STDataType STTop(ST* ps)
{
	assert(ps);

	assert(ps->top > 0);

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

int STsize(ST* ps)
{
	assert(ps);

	return ps->top;
}

二.队列

1.队列的特性：

    只允许在一端进行插入数据操作，另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO（First in First Out）。

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

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

2.队列的存储结构：   

      我们一般用链式结构实现队列。

                                                                                                                                                                                                                                                                                                                             

typedef int QDataType;
//链式结构表示队列
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
//队列的结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que; 

  3. 队列的实现                   

   功能函数：

void QueueInit(Que* pq);//初始化
void QueueDestroy(Que* pq);//销毁
void QueuePush(Que* pq, QDataType x);//入队
void QueuePop(Que* pq);//出队
QDataType QueueFront(Que* pq);//取队头元素
QDataType QueueBack(Que* pq);//取队尾元素
bool QueueEmpty(Que* pq);//队列空
int QueueSize(Que* pq);//队列元素个数

   具体实现：

void QueueInit(Que* pq)
{
	assert(pq);

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


void QueuePush(Que* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail ==  NULL)
	{
		pq->head = pq->tail = newnode;
	}

	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}


bool QueueEmpty(Que* pq)
{
	assert(pq);

	return pq->head == NULL;
}
void QueuePop(Que* pq)
{
	assert(pq);

	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}

	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}
//取队头元素
QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}



void QueueDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;

	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
		
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;
}

          以上就是本篇内容，创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，如果喜欢我的文章，给个关注吧！

如果本篇博客有任何错误，请批评指教，不胜感激 ！