文章目录
一、栈
1. 栈的概念及结构
栈:一种特殊的线性表,只允许在固定的一端进行插入和删除元素操作。
进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。
栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
出栈:栈的删除操作叫做出栈。栈顶出数据。
2. 栈的实现
栈的实现一般可以使用数组或者链表实现,相对而言用数组实现是更优解。因为数组在尾上插入数据的代价比较小
- 数组实现:
- 链表实现:
2.1 接口
- Stack.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//用数组实现
typedef int STDataType;
typedef struct
{
STDataType* data;
int top;//栈顶
int capacity;
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
2.2 顺序栈的实现
初始化栈
void StackInit(Stack* ps)
{
assert(ps);
ps->data = NULL;
ps->top = ps->capacity = 0;
}
入栈
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
if (ps->top == ps->capacity)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->data, sizeof(STDataType) * newCapacity);
if (tmp == NULL)
{
perror("malloc failed\n");
return;
}
ps->data = tmp;
ps->capacity = newCapacity;//别忘记更新capacity
}
ps->data[ps->top] = data;
ps->top++;
}
判空
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}
出栈
void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
ps->top--;
}
获取栈顶元素
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->data[ps->top - 1];
}
获取栈中有效元素个数
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
销毁栈
void StackDestroy(Stack* ps)
{
assert(ps);
free(ps->data);
ps->data = NULL;
ps->top = ps->capacity = 0;
}
2.3 TestStack
void TestStack()
{
ST st = { 0 };
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
StackPush(&st, 5);
while (!StackEmpty(&st))
{
printf("%d ", StackTop(&st));
StackPop(&st);
}
}
二、队列
1. 队列的概念及结构
队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out)
入队列:进行插入操作的一端称为队尾
出队列:进行删除操作的一端称为队头
2. 队列的实现
队列也可以数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数组的结构,出队列在数
组头上出数据,效率会比较低。
2.1 接口
- Queue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//队列:队头出,队尾插
// 链式结构:表示队列
typedef int QDataType;
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;
// 队列的结构
typedef struct Queue
{
QNode* front;
QNode* rear;
int size;//
}Queue;
// 初始化队列
void QueueInit(Queue* pq);
// 队尾入队列
void QueuePush(Queue* pq, QDataType data);
// 队头出队列
void QueuePop(Queue* pq);
// 获取队列头部元素
QDataType QueueFront(Queue* pq);
// 获取队列队尾元素
QDataType QueueBack(Queue* pq);
// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* pq);
// 销毁队列
void QueueDestroy(Queue* pq);
2.2 实现(单链表)
- Queue.c
初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->front = pq->rear = NULL;
pq->size = 0;
}
队尾入队列
void QueuePush(Queue* pq, QDataType data)
{
assert(pq);
QNode* newNode = (QNode*)malloc(sizeof(QNode));
if (newNode == NULL)
{
perror("malloc failed\n");
return;
}
newNode->data = data;
newNode->next = NULL;
if (pq->front == NULL)
{
pq->front = pq->rear = newNode;
}
else
{
pq->rear->next = newNode;
pq->rear = newNode;
}
pq->size++;
}
队头出队列
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
//最后一个
if (pq->front->next == NULL)
{
free(pq->front);
pq->front = pq->rear = NULL;//记得把rear置空
}
else
{
QNode* del = pq->front;
pq->front = pq->front->next;
free(del);
del = NULL;
}
pq->size--;
}
获取队列头部元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->front->data;
}
获取队列队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
return pq->rear->data;
}
判空
// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* pq)
{
return pq->front == NULL && pq->rear == NULL;
}
获取队列中有效元素个数
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
销毁队列
void QueueDestroy(Queue* pq)
{
assert(pq);
QNode* cur = pq->front;
while (cur)
{
QNode* del = cur;
cur = cur->next;
free(del);
del = NULL;
}
pq->front = pq->rear = NULL;
}
3. TestQueue
void TestQueue()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
while (!QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
//printf("\n");
QueueDestory(&q);
}
以上就是本文的所有内容,如有错误,请指正。🌹