用C语言创建基本的栈与队列

目录

  • 一:栈
    • 1.什么是栈?
    • 2.数组栈与链式栈哪个更优?
    • 3.栈的实现
      • Stack.h
      • Stack.c
        • <1> StackInit
        • <2> StackPop
        • <3> StackPush
        • <4> StackDestroy
        • <5> StackTop
        • <6> StackSize
        • <7> StackEmpty
        • <8> 测试效果
  • 二:队列
    • 1.什么是队列?
    • 2.数组队列与链式队列哪个更优?
    • 3.队列的实现
      • Queue.h
      • Queue.c
        • <1> QueueInit
        • <2> QueueDestroy
        • <3> QueuePush
        • <4> QueuePop
        • <5> QueueFront
        • <6> QueueBack
        • <7> QueueSize
        • <8> QueueEmpty
        • <9> 测试效果

一:栈

1.什么是栈?

  • 栈,是一种特殊的线性表,它只允许在固定的一端进行插入和删除元素的操作。进行数据插入和删除的一端称为栈顶,另一端称为栈底。
  • 遵循后进先出(Last In First Out)的原则。
    用C语言创建基本的栈与队列_第1张图片

2.数组栈与链式栈哪个更优?

  • 如果利用链式结构实现栈,因为栈遵循后入先出,我们需要在栈顶进行插入和删除操作,如果把单链表的尾作为栈顶,插入方便,但是不利于删除,要设计成双向链表
  • 如果把单链表的头作为栈顶,头插头删比较方便,利于实现栈,但由于在内存中不是顺序存储,CPU缓存利用率较低。
  • 如果利用数组结构实现栈,将数组最后一个位置当做栈顶,进行插入删除操作同样方便,并且不需要多存储一个指针,由于是顺序存储,CPU缓存利用率更高,缺点是需要增容,会有一定的消耗。
  • 综上,利用数组或者链式结构实现栈均可,各有优缺点,我下面讲述实现栈的方式利用的数组结构。

3.栈的实现

Stack.h

  • 利用数组实现栈,我们除了需要数组以外还需要两个变量
  • 一个是top,指向的是栈顶,方便进行插入和删除操作,一个是capacity,存储目前数组的大小,空间不够时需要扩容,将它们三个装进一个结构体中,我们的栈的框架就搭建好了。
  • 剩下我们需要对栈进行初始化,删除,插入,查询栈顶元素,查询大小,查询是否为空,销毁这些操作,将对应的函数都在头文件中进行初始化。
  • 剩下的工作就是实现对应的函数了。
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
#include
#include

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void StackInit(ST* ps);
void StackPop(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackDestroy(ST* ps);
STDataType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);

Stack.c

<1> StackInit

  • 每一个函数首先都需要对参数ps进行判断,它代表的是栈的地址,不可能为空(除非参数传错),使用断言的方式如果我们传了NULL还能报错提醒我们,十分地合适。
  • 接下来就是简单的初始化,将a置为NULL,将top和capacity置为0
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

<2> StackPop

  • 删除的操作需要判断栈是否为空,可以直接调用StackEmpty函数
  • 接下来只要将top自减一就足够了,保证我们找不到它,不用真的删除
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

<3> StackPush

  • 进行插入之前需要对数组大小进行判断,如果数组容量不够,即top==capycity时需要进行扩容。
  • 扩容成功后将数组的top位置数据改为传入的参数x,再将top++,指向下一个待插入元素的位置,注意top不指向最后一个元素
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)
		{
			perror("realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = NewCapacity;
	}

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

<4> StackDestroy

  • 销毁链表十分的简单,只需要先释放a,再让a指向NULL,top和capacity置为0即可
  • 其实好像和初始化没区别
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

<5> StackTop

  • 这个函数是用于查询栈顶元素并返回栈顶元素的值,所以栈为空就不用查询了,查了也是一个随机值,故先对栈不为空进行断言。
  • 之后返回的位置需要注意,是返回a[top-1],不是top,因为top指向的是最后一个元素的下一个位置。
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

<6> StackSize

  • top的大小其实就是栈的大小
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

<7> StackEmpty

  • 只要top为0,栈就为空,其它时候都不为空
  • 所以可以直接返回表达式ps->top == 0,如果成立证明栈为空返回的为Ture,否则返回False
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

<8> 测试效果

  • 可以看到先入压栈压入1和2,之后出栈,再让3、4入栈,之后再将剩余元素出栈
  • 因为2在1后入栈,根据后入先出,2先出栈,3,4同样如此,最终2先出栈,然后出4、3,最终1才出栈。
    用C语言创建基本的栈与队列_第2张图片

二:队列

1.什么是队列?

  • 队列,同样是一种特殊的线性表,它只允许在一端进行插入数据的操作,在另一端进行删除数据的操作进行数据插入一端称为队尾,进行数据删除的一端称为队头。
  • 遵循先进先出(First In First Out)的原则。
    用C语言创建基本的栈与队列_第3张图片

2.数组队列与链式队列哪个更优?

  • 如果利用链式结构实现队列,将头节点当做队头,链尾当做队尾,进行头删十分方便,但单链表的尾插需要遍历链表,时间复杂度为O(N),为了避免每次都寻找链表的尾部,可以在一开始就定义一个尾指针指向尾部,每次插入以后改变尾指针的位置,就可以避免频繁查找。
  • 如果利用数组结构实现队列,将数组最后一个位置为队尾,数组第一个位置为队头,在尾部插入操作很方便,但需要在头部进行删除操作,这需要对数组进行遍历,时间复杂度为O(N),效率低。
  • 综上,利用链式结构实现队列效率更高。

3.队列的实现

Queue.h

  • 利用单链表实现队列,上文提及,除了需要头指针以外,还需要尾指针便于尾插。
  • 将链表的每个节点,指针域和数据域封装进一个结构体,将头指针和尾指针装入另一个结构体,避免对每个函数都需要多传头指针和尾指针两个参数。
  • 剩下我们需要对队列进行初始化,删除,插入,查询队头队尾元素,查询大小,查询是否为空,销毁这些操作,将对应的函数都在头文件中进行初始化。
  • 剩下的工作就是实现对应的函数了。
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
#include
#include

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

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

}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

Queue.c

<1> QueueInit

  • 每一个函数首先都需要对参数pq进行判断,它代表的是队列的地址,不可能为空(除非参数传错),使用断言的方式如果我们传了NULL还能报错提醒我们,十分地合适。
  • 由于队列一开始没有节点,故头尾节点均指向NULL
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}

<2> QueueDestroy

  • 销毁队列时需要注意,不能直接free(pq->head)
  • 需要对每个节点都进行free,之后将头尾节点都置为NULL。
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

<3> QueuePush

  • 插入元素时首先申请一个新的节点,之后判断队列是不是空,如果是空将头尾指针同时指向新节点就插入完成
  • 如果队列不为空,将尾指针的next指向NewNode,之后再移动尾指针的位置指向新的尾
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* NewNode = (QueueNode*)malloc(sizeof(QueueNode));
	NewNode->next = NULL;
	NewNode->data = x;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = NewNode;
	}
	else
	{
		pq->tail->next = NewNode;
		pq->tail = NewNode;
	}
}

<4> QueuePop

  • 删除队列元素需要对队列是否为空进行判断,为空就不能继续删除了,可以直接调用QueueEmpty函数。
  • 之后新建变量next指向头结点的下一节点,再释放头结点,将头指针指向新的头节点,就删除成功了
  • 还有一个细节需要注意,我们一直没有动尾指针,但是这样当队列为空时尾指针就会变成野指针,所以当队列为空即头指针为空时,代表已经删除了最后一个元素时,我们需要将尾指针也置为NULL
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

<5> QueueFront

  • 不为空就返回头节点的值
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

<6> QueueBack

  • 不为空就返回尾节点的值
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

<7> QueueSize

  • 从头节点开始遍历队列计算元素个数,cur为NULL时停止
int QueueSize(Queue* pq)
{
	int n=0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		n++;
		cur = cur->next;
	}
	return n;
}

<8> QueueEmpty

  • 如果头指针为NULL代表队列为空,否则队列不为空
  • 故可以直接返回pq->head == NULL,如果表达式为真,代表头指针为NULL,返回True,代表队列为空,否则返回False
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

<9> 测试效果

  • 如图,先插入1,2,然后出队列,再插入3,4,再出声音队列
  • 最终结果为1,2,3,4,可见无论什么时候出队列都遵循先入先出的规则

用C语言创建基本的栈与队列_第4张图片

你可能感兴趣的:(数据结构与算法学习笔记,c语言,数据结构,经验分享)