数据结构第三章栈和队列-CSDN博客

本文链接：https://blog.csdn.net/nigulasihjznskn/article/details/132683395

第三章栈和队列

一、栈（Stack）

栈

栈的基本概念

栈（Stack）是只允许在一端进行插入或删除操作的线性表

重要术语：栈顶，栈底，空栈

逻辑结构上：与普通的线性表相同

数据的运算：插入、删除操作有区别，栈只能在栈顶的位置进行相关操作

栈的基本操作

栈的常考题型

考试时不会让你把所有的顺序写出来，一般都是选择题，让你判断某种出栈的顺序是否合法

栈的顺序存储实现

基本操作

#define MAXSIZE 10
typedef struct
{
	int data[MAXSIZE];
	int top;//表示栈顶元素的下标
}SqStack;

初始化（创）：

//--------初始化
void InitSqStack(SqStack* S)
{
	(*S).top = -1;//初始化栈顶指针，数组首元素还未赋值，指向0不合理
}

进栈（增）：

//--------进栈
int Push(SqStack* S,int t)
{
//判满
	if ((*S).top == MAXSIZE - 1)
	{
		return 0;
	}
	(*S).top += 1;
	(*S).data[(*S).top] = t;
	//等价于(*S).data[++(*S).top] = t;
	return 1;
}

出栈（删）：

//--------出栈
int Pop(SqStack* S, int s)
{
//判空
	if ((*S).top == -1)
	{
		return 0;
	}
	s = (*S).data[(*S).top];
	(*S).top = (*S).top - 1;
	//等价于s = (*S).data[(*S).top--];
	return 1;
}

被删除的元素还惨留在内存中，只是逻辑上被删除了。

获取栈顶元素（查）：

//--------获取栈顶元素
int GetTop(SqStack* S,int* h)
{
//判空
	if ((*S).top == -1)
	{
		return 0;
	}
	*h = (*S).data[(*S).top];
	return 1;
}

另一种方式：

判空、判满

//判空
if ((*S).top == -1)
{
	return 0;
}

//判满
if ((*S).top == MAXSIZE - 1)
{
	return 0;
}

共享栈

栈的链式存储

链栈的定义：

和单链表的定义几乎没有什么区别，单链表的链头 = 栈顶

typedef struct LinkNode
{
	int data;
	struct LinkNode* next;
}LNode,*LiStack;

初始化（创）：

//--------初始化
void InitLiStack(LiStack *S)
{
	*S = (LNode*)malloc(sizeof(LNode));
	(*(*S)).next = ((void*)0);
}

进栈（增）：

//--------进栈(单链表的头插)
void Push(LiStack* S)
{
	int t = 0;
	printf("输入9999退出\n");
	scanf("%d", &t);
	while (t != 9999)
	{
		LNode*L = (LNode*)malloc(sizeof(LNode));
		(*L).data = t;
		(*L).next = (*(*S)).next;
		(*(*S)).next = L;
		printf("输入9999退出\n");
		scanf("%d", &t);
	}
}

出栈（删）：

//--------出栈
void Pop(LiStack* S)
{
	LNode* q = (*(*S)).next;
	(*(*S)).next =(*q).next;	
	free(q);
	q = NULL;
}

获取（栈顶元素）：

//获取栈顶元素
int gettop(LiStact* S, int* z)
{
	LNode* p = (*(*S)).next;//用指针p指向下一个节点
	*z = (*p).data;
	/*不用额外定义指针，直接硬套*/
	/**z = (* (  (*(*S)).next  ) ).data;*/
}

二、队列（Queue）

1.队列

定义：

队列（Queue）是只允许在一端进行插入，在另一端进行删除的线性表，队列的插入操作一般称为入队，队列的删除操作一般称为出队。

特点：先进入队列的元素先出队

队列的几个术语：队头、队尾、空队列

对头：允许删除的一端

队尾，允许插入的一端

2.队列顺序存储实现

初始化（创）：

//--------初始化
void InitQueue(SqQueue* Q)
{
	//初始 队头、队尾下标指向0
	(*Q).rear = (*Q).front = 0;
}
//--------判空
int QueueEmpty(SqQueue* Q)
{
	return ((*Q).rear ==(*Q).front);
}

这里注意，rear是指向队尾后一个元素下标，还是就是指向队尾的下标

入队（增）：

//--------入队
int EnQueue(SqQueue* Q,int e)
{
	//判满条件
	//代价：需要牺牲一个空间让rear指向它
	if (((*Q).rear + 1) % MAXSIZE == (*Q).front)
	{
		return 0;//入队失败
	}
	(*Q).data[(*Q).rear] = e;
	(*Q).rear = ((*Q).rear + 1) % MAXSIZE;
	return 1;//入队成功
}

运用模运算将存储空间在逻辑上变成“环状”

出队（删）：

//--------出队
int DeQueue(SqQueue* Q,int* x)
{
	//判空
	if ((*Q).rear == (*Q).front)
	{
		return 0;//出队失败
	}
	(*x) = (*Q).data[(*Q).front];
	(*Q).front = ((*Q).front - 1) % MAXSIZE;
	return 1;//出队成功
}

获取队头元素（查）：

//--------查
int DeQueue(SqQueue* Q, int* y)
{
	//判空
	if ((*Q).rear == (*Q).front)
	{
		return 0;//查找失败
	}
	(*y) = (*Q).data[(*Q).front];
	return 1;//查找成功
}

判满、判空

//判满条件
//代价：需要牺牲一个空间让rear指向它
if (((*Q).rear + 1) % MAXSIZE == (*Q).front)
{
	return 0;
}

//--------判空
int QueueEmpty(SqQueue* Q)
{
	return ((*Q).rear == (*Q).front);
}

不浪费存储空间的方法：

方法1：

#define MAXSIZE 10
typedef struct
{
	int data[MAXSIZE];//静态数组存放队列元素
	int front, rear;//队头下标 和 队尾下标
	int size; //当前队列的长度
}SqQueue;

        插入成功时 size++

        删除成功时 size--

        判满条件：size == MAXSIZE;

        判空条件：size == 0;

方法2：

#define MAXSIZE 10
typedef struct
{
	int data[MAXSIZE];//静态数组存放队列元素
	int front, rear;//队头下标 和 队尾下标
	int tag; //最近进行的是删除/插入  0/1
}SqQueue;

        插入成功，令tag=1；

        删除成功，令tag=0

        判满条件：front == rear && tag == 1

        判空条件：front == rear && tag == 0

3.队列链式存储实现

typedef struct LinkNode//链式队列 结点
{
	int data;
	struct LinkNode* next;
}LinkNode;

typedef struct//链式队列
{
	LinkNode* front, * rear;
}LinkQueue;

初始化

带头节点：

//--------初始化（带头结点）
void InitLinkQueue(LinkQueue* Q)
{
	//初始时 front,rear 都指向头结点
	(*Q).front = (*Q).rear = (LinkNode*)malloc(sizeof(LinkNode));
	(*(*Q).front).next = NULL;
}

同时我们可以知道判空的条件

//--------判空（带头结点）
int IsEmpty(LinkQueue* Q)
{
	if ((*Q).front == (*Q).rear)
	{
		return 1;//是空
	}
	return 0;//不是空
}

不带头节点：

//--------初始化（不带头结点）
void InitLinkQueue(LinkQueue* Q)
{
	//初始时 front,rear 都指向空
	(*Q).front = NULL;
	(*Q).rear = NULL;
}

同时我们可以知道判空的条件

//--------判空（不带头结点）
int IsEmpty(LinkQueue* Q)
{
	if ((*Q).front == NULL)
	{
		return 1;//是空
	}
	return 0;//不是空
}

入队

带头结点：

//--------入队（带头结点）
void EnQueue(LinkQueue* Q)
{
	int t;
	printf("请输入数值:>");
	scanf("%d", &t);
	LinkNode*L = (LinkNode*)malloc(sizeof(LinkNode));
	(*L).data = t;
	(*L).next = NULL;
	(*(*Q).rear).next = L;
	(*Q).rear = L;
}

不带头结点：

void EnQueue(LinkQueue* Q)
{
	int t;
	printf("请输入数值:>");
	scanf("%d", &t);
	LinkNode* S = (LinkNode*)malloc(sizeof(LinkNode));
	(*S).data = t;
	(*S).next = NULL;
	if ((*Q).front == NULL)
	{
		(*Q).front = S;
		(*Q).rear = S;
	}
	(*(*Q).rear).next = S;
	(*Q).rear = S;
}

注意要关注rear的操作

出队

带头结点

//--------出队（带头结点）
int DeQueue(LinkQueue* Q,int* x)
{
	//判空
	if ((*Q).front == (*Q).rear)
	{
		return 0;//出队失败
	}
	LinkNode* p = (*(*Q).front).next;
	x = (*p).data;
	(*(*Q).front).next = (*p).next;
	//如果是最后一个结点
	if ((*(*Q).front).next == (*Q).rear)
	{
		(*Q).rear = (*Q).front;
	}
	free(p);
	return 1;
}

不带头结点

int DeQueue(LinkQueue* Q, int* x)
{
	//判空
	if ((*Q).front == NULL)
	{
		return 0;//出队失败
	}
	LinkNode* p = (*Q).front;
	x = (*p).data;
	(*(*Q).front).next = (*p).next;
	//如果是最后一个结点
	if (p == (*Q).rear)
	{
		(*Q).rear = (*Q).front = NULL;
	}
	free(p);
	return 1;
}

注意要关注front的操作