数据结构——栈、队列（超详细，一文看懂，附代码）

什么是数据结构：https://blog.csdn.net/L_Blue_/article/details/134643425?spm=1001.2014.3001.5502s​​​​​​​s

栈

特点：先进后出

作用

        做某些算法会用到，特别是需要回溯的思想，递归

        空栈 top对应下标没有元素

        满栈 top 对应下标有元素

        递增 入栈地址向高地址移动

        递减 入栈地址向低地址移动

顺序栈和顺序表的区别

        顺序表做插入和删除的位置没有规定，并且删除和插入需要每个元素依次移动，顺序栈插入和删除不需要做元素的依次移动，使用栈顶的下标移动实现插入和删除

队列

特点：

        先进先出

        异步执行

        顺序队列

循环队列（顺序）

        判空 ：f == r len == 0

        判满：(r+1)%size = f len == size

        头尾移动：(r+1)%N     (f+1)%N

链式队列

        组成

                1链表

                2 保存链表头尾的结构体

        操作

                出队：从头出（头节点的下一个节点）， 保存节点，保存节点的数据，连线，free。注意 ~~~~ 如果出的是最后一个节点， r = f

                入队：从尾入（尾插）， 入队完毕，r = new；

顺序栈代码

头文件：

#ifndef _SQSTACK_H
#define _SQSTACK_H

#define SIZE 1024

typedef int sqs_data_t;

typedef struct sqstack{
	sqs_data_t data[SIZE];
	int top;
}sqs_node, *sqs_pnode;


sqs_pnode create_sqstack();

sqs_data_t output_sqstack(sqs_pnode S);

int input_sqstack(sqs_pnode S, sqs_data_t data);

int empty_sqstack(sqs_pnode S);

int full_sqstack(sqs_pnode S);

#endif

函数功能实现：

#include <stdlib.h>
#include "sqstack.h"

//创建
sqs_pnode create_sqstack()
{
	sqs_pnode S = (sqs_pnode)malloc(sizeof(sqs_node));
	if(NULL == S)
		return NULL;
	
	//空递增栈
	S->top = 0;
	
	return S;
}
//出栈
sqs_data_t output_sqstack(sqs_pnode S)
{
	if(NULL == S)
		return -1;
	
	if(0 == empty_sqstack(S))
		return -2;
	
	return S->data[--(S->top)];
}
//入栈
int input_sqstack(sqs_pnode S, sqs_data_t data)
{
	if(NULL == S)
		return -1;
	
	if(0 == full_sqstack(S))
		return -2;
	
	S->data[(S->top)++] = data;
	
	return 0;
}
//判空
int empty_sqstack(sqs_pnode S)
{
	if(NULL == S)
		return -1;
	
	if(0 == S->top)
		return 0;
	else
		return 1;
}
//判满
int full_sqstack(sqs_pnode S)
{
	if(NULL == S)
		return -1;
	
	if(SIZE == S->top)
		return 0;
	else
		return 1;
}

顺序队列代码

头文件：

#ifndef _SQQUEUE_H
#define _SQQUEUE_H

typedef int sqq_data_t;

#define SIZE 1024

typedef struct sqqueue{
	sqq_data_t data[SIZE];
	int r, f;
}sqq_node,*sqq_pnode;	

sqq_pnode create_sqqueue();

int empty_sqqueue(sqq_pnode Q);

int full_sqqueue(sqq_pnode Q);

int input_sqqueue(sqq_pnode Q, sqq_data_t data);

sqq_data_t output_sqqueue(sqq_pnode Q);



#endif

函数功能实现：

#include <stdlib.h>
#include "sqqueue.h"

sqq_pnode create_sqqueue()
{
	sqq_pnode Q = (sqq_pnode)malloc(sizeof(sqq_node));
	if(NULL == Q)
		return NULL;
	
	Q->r=Q->f=0;
	
	return Q;
}
int empty_sqqueue(sqq_pnode Q)
{
	if(NULL == Q)
		return -1;
	if(Q->r == Q->f)
		return 0;
	else
		return 1;
}
int full_sqqueue(sqq_pnode Q)
{
	if(NULL == Q)
		return -1;
	
	if((Q->r+1)%SIZE == Q->f)
		return 0;
	else
		return 1;
}
int input_sqqueue(sqq_pnode Q, sqq_data_t data)
{
	if(NULL == Q)
		return -1;
	if(0 == full_sqqueue(Q))
		return -2;
	
	Q->data[Q->r] = data;
	Q->r = (Q->r + 1) % SIZE;
	
	return 0;
}
sqq_data_t output_sqqueue(sqq_pnode Q)
{
	if(NULL == Q)
		return -1;
	if(0 == empty_sqqueue(Q))
		return -2;
	
	sqq_data_t data = Q->data[Q->f];
	Q->f = (Q->f + 1) % SIZE;
	
	return data;
}

链队列代码

头文件：

#ifndef _LINKQUEUE_H
#define _LINKQUEUE_H

typedef int data_t;

typedef struct linkliste
{
	           data_t data;
	struct linkliste* next;
	
}lkl_node, *lkl_pnode;

typedef struct linkqueue
{
	lkl_pnode head, end;
	
}lkq_node, *lkq_pnode;

//创建
lkq_pnode create_linkqueue();
//判空
int empty_linkqueue(lkq_pnode Q);
//出队
data_t output_linkqueue(lkq_pnode Q);
//进队
int input_linkqueue(lkq_pnode Q,data_t data);

#endif

函数功能实现：

#include <stdlib.h>
#include "linkqueue.h"


lkq_pnode create_linkqueue()
{
	lkl_pnode L = (lkl_pnode)malloc(sizeof(lkl_node));
	if(NULL  == L)
		return NULL;
	
	lkq_pnode Q = (lkq_pnode)malloc(sizeof(lkq_node));
	if(NULL  == Q)
		return NULL;
	
	Q->head = Q->end = L;
	
	return Q;
}
//------------------------判空------------------------------------
int empty_linkqueue(lkq_pnode Q)
{
	if(NULL == Q)
		return -1;
	if(Q->head == Q->end)
		return 0;
	else
		return 1;
}
//------------------------出队------------------------------------
data_t output_linkqueue(lkq_pnode Q)
{
	if(NULL == Q)
		return -1;
	if(0 == empty_linkqueue(Q))
		return -2;
	if(Q->head->next->next == NULL)
		Q->end = Q->head;
	
	lkl_pnode del = Q->head->next;
	data_t data = del->data;
	Q->head->next = del->next;
	free(del);
	return data;
}
//-----------------------入队-------------------------------------
int input_linkqueue(lkq_pnode Q,data_t data)
{
	if(NULL == Q)
		return -1;
	lkl_pnode new  = (lkl_pnode)malloc(sizeof(lkl_node));
	if(NULL == new)
		return -2;
	new->data = data;
	Q->end->next = new;
	new->next = NULL;
	Q->end = new;
	return 0;
}