数据结构:栈和队列

栈

概念

栈是一种特殊的线性表,其只允许在固定的一端插入和删除元素的操作,进行数据插入和删除操作的一端称为栈顶,另一端为栈底,原则就是先进栈的后出栈,后进栈的先出栈

压栈:栈的插入操作也叫进栈/压栈/入栈,入数据在栈顶

出栈:栈的删除操作叫做出栈,出数据也在栈顶

 

栈可以由链表实现,同时也可以用顺序表实现

栈用链表实现的图解如下,可以设计成尾插也可以是头插

我们把一开始设置成栈底,后面就是栈顶,数据从栈顶进栈,从栈顶出栈,这样放数据的方式在链表中就是尾插,我们发现插入和删除数据的时候还需要先便利一边整个链表,找到最后一个节点,这样的话我就得写一个双向链表,直接从头节点找到尾节点,更加方便插入删除数据

还有一种插入删除数据的方式就是头插,我们将栈底和栈顶调换一下位置,我们从头部开始插入数据,删除的时候也是在头部删除,就会方便许多

栈也可以用顺序表来实现,我们把这种叫做数组栈

数据的插入删除在栈顶,正好数组中的进出数据就是在尾部,所以用数组栈较好一些

代码实现

那我们就用代码来实现,代码和顺序表的代码大体相似

头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include <assert.h>

typedef int STDataType;
typedef struct Stack {
	STDataType* a;
	int top;
	int capacity;
}ST;

void StackInit(ST * ps);
void StackPush(ST* ps, STDataType x);
void StackPrint(ST* ps);
void StackDestroy(ST* ps);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);

解释一下:typedef int STDataType;将整型改换名称,改为STDataType,如果说数组要存储char类型,那么我们就把int改成char即可,不用在下面一个一个的更改了

我们定义一个结构体,结构体中的参数有一个指针,这个指针可以表示一个整型的数组的指针,即int*

top是栈顶,俗话就是我们说的这个数组的长度,capacity是这个数组的容量是多少

这里我们具体来说一下初始化函数和StackPush函数

函数实现

void StackInit(ST* ps) {
	assert(ps);
	ps->a = NULL;
	ps->top = 0;//ps->next = -1;  
	ps->capacity = 0;
}
void StackPush(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)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}

测试函数

#include"Stack.h"
void test1()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPrint(&st);
}
int main()
{
	test1();
	return 0;
}

我们测试函数中传递参数是结构体st的地址,接受就是用一级指针来接收的,传指针是为了找到结构体在内存中的位置,我们没有改变这个地址,我们只是想改变结构体中的内容,所以传一级指针就可以了,插几句在我写的单向链表中我们传来的是plist的地址,一开始plist指向空,我们想改变传来的plist的地址,所以我们才用的二级指针,但是加上一个哨兵位就不一样了,哨兵位就是一个哨兵我们在整个链表中设置的一个头节点通过这个哨兵的地址我们可以找到这个链表,我们添加内容的时候直接改变这个哨兵指向的内容就行,我们没有改变哨兵的地址所以传一级指针就行咯.

在尾插的时候先要看看是不是要扩容,检验的扩不扩容的标准就是我们top看看是不是和capacity相等不,top是最外面的值,如果最上面值的下标和capacity相等了说明栈就满了

队列

概念

只允许在一端进行插入数据,在另一端删除数据操作的特殊线性表,队列具有先进先出

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

出队列:进行删除操作的一端称为对头

由于涉及到了头和尾的问题用顺序表就显得非常难搞,因为顺序表你可以在队尾添加,但是删除开头的之后后面的数据需要往前移,就显得非常的难搞,所以我们实现队列的时候用的是单向链表,但是我们定义单项链表的时候,要标注出他的头节点和尾节点,方便对队列的操作

代码实现

我们先来实现结构体

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include <assert.h>
typedef int QDataType;

typedef struct QueueNode {
	struct QueueNode* next;
	QDataType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

我们这时候定义了两个结构体,第一个结构体是对每一个节点,第二个结构体是对整个队列的,在队列中标注出来头节点和尾节点

然后我们来实现相关的函数

void StackInit(ST * ps);
void StackPush(ST* ps, STDataType x);
void StackPrint(ST* ps);
void StackDestroy(ST* ps);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);

(1)对队列进行进行初始化的函数

我们在测试函数中来整一行这个代码:Queue q; QueueInit(&q); 特别注意的是我们传的是队列的地址

#include "Queue.h"
void QueueInit(Queue* pq)//给队列进行初始化
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

上面是对具体函数的实现,我们对队列里的值(头节点和尾节点)进行更改,不会影响到队列的地址,所以接受实参的形参用一级指针

void QueueDestroy(Queue* pq) {
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur != NULL)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)//在队尾增加数据
{
	assert(pq);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	newNode->data = x;
	newNode->next = NULL;
	if (pq->head == NULL)
	{
		pq->tail = pq->head = newNode;
	}
	else {
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
	
}
void QueuePop(Queue* pq)//在队头删除数据
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* cur = pq->head->next;
	free(pq->head);
	pq->head = cur;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}
QDataType QueueFront(Queue* pq)//取出对头的数据
{
	assert(pq);
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)//取出队尾的数据
{
	assert(pq);
	return pq->tail->data;
}
int QueueSize(Queue* pq)
{
	int count = 0;
	QueueNode* cur = pq->head;
	while (cur != NULL)
	{
		cur = cur->next;
		count++;
	}
	return count;
}
bool QueueEmpty(Queue* pq)
{
	return pq->head == NULL;
}
void QueuePrint(Queue* pq) {
	QueueNode* cur = pq->head;
	while (cur != NULL)
	{
		printf("%d ", cur->data);
		cur = cur->next;
		
	}
}

测试代码

#include"Queue.h"
void Test1() {
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePush(&q, 7);
	QueuePrint(&q);
    printf("\n");
	QueuePop(&q);
	QueuePrint(&q);
	printf("\n");
	int a = QueueFront(&q);
	printf("%d\n", a);
	int b = QueueBack(&q);
	printf("%d\n", b);
}
int main()
{
	Test1();
	return 0;
}

测试结果为