目录
一：栈
1.1：栈的概念结构与实现
1.1.1：栈的概念结构
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
形象数据演示入栈/出栈过程：
1.1.2：栈的实现
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
数组的结构实现：
并且在实际应用中，我们一般主要实现支持动态增长的栈：
// 实现一个栈
typedef int STDatatype;
typedef struct Stack
{
STDatatype* a;
int top; // 栈顶
int capacity; // 容量
}ST;1.2：栈的各个功能实现
1.2.1：对栈进行初始化
因为栈是使用数组来实现的，所以在对栈进行操作之前必须要先对栈进行初始化（此处将栈顶的初始值置为0）。
1.2.2：判空栈
当栈顶top==0时，该函数返回true，否则返回false。
1.2.3：入栈
因为栈是由数组来实现的，所以当数据进行入栈的时候一定要对栈的容量进行检查。当容量满的时候需要进行扩容。
1.2.4：出栈
1.2.5：获取栈顶元素
因为栈顶原本初始值为0，即先放入数据后，top++。所以获取栈顶元素时获取的是top-1的位置的数据。
1.2.6：获取栈内元素个数
1.2.7；销毁栈
1.3：栈的源代码
1.3.1：Stack _Func.h 代码实现
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
// 实现一个栈
typedef int STDatatype;
typedef struct Stack
{
STDatatype* a;
int top; // 栈顶
int capacity; // 容量
}ST;
// 初始化栈
void ST_Init(ST* pst);
// 判空
bool ST_Empty(ST* pst);
// 入栈
void ST_Push(ST* pst, STDatatype x);
// 出栈
void ST_Pop(ST* pst);
// 获取栈顶元素
STDatatype ST_Top(ST* pst);
// 获取栈内元素个数
int ST_Size(ST* pst);
// 销毁栈
void ST_Destroy(ST* pst);1.3.2：Stack _Func.c 代码实现
#include"Stack_Func.h"
// 初始化栈
void ST_Init(ST* pst)
{
pst->a = NULL;
pst->capacity = 0;
pst->top = 0;
}
// 判空
bool ST_Empty(ST* pst)
{
return pst->top == 0;
}
// 入栈
void ST_Push(ST* pst, STDatatype x)
{
// 增容
if (pst->capacity == pst->top)
{
int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
STDatatype* tmp = (STDatatype*)realloc(pst->a, sizeof(STDatatype) * newcapacity);
if (tmp == NULL)
{
perror("ST_Push realloc fail");
return;
}
pst->a = tmp;
pst->capacity = newcapacity;
}
// 入栈
pst->a[pst->top] = x;
pst->top++;
}
// 出栈
void ST_Pop(ST* pst)
{
assert(!ST_Empty(pst));
pst->top--;
}
// 获取栈顶元素
STDatatype ST_Top(ST* pst)
{
assert(!ST_Empty(pst));
return pst->a[pst->top - 1];
}
// 获取栈内元素个数
int ST_Size(ST* pst)
{
return pst->top;
}
// 销毁栈
void ST_Destroy(ST* pst)
{
free(pst->a);
pst->a = NULL;
pst->capacity = pst->top = 0;
}1.3.3：Stack _Main.c 代码实现
#include"Stack_Func.h"
int main()
{
ST st;
// 初始化栈
ST_Init(&st);
// 入栈
ST_Push(&st, 1);
ST_Push(&st, 2);
ST_Push(&st, 3);
ST_Push(&st, 4);
ST_Push(&st, 11);
ST_Push(&st, 33);
ST_Push(&st, 22);
ST_Push(&st, 55);
printf("栈内元素个数： = > %d\n", ST_Size(&st));
while (!ST_Empty(&st))
{
printf("%d ", ST_Top(&st));
ST_Pop(&st);
}
printf("\n");
ST_Destroy(&st);
}运行结果：
二：队列
2.1：队列的概念结构与实现
2.1.1：队列的概念及结构
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾。
出队列：进行删除操作的一端称为队头。
队列结构：
2.2.2：队列的实现
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
队列实现情况：
所以对于描述一个队列，就可以这样：
// 实现一个队列
typedef int QEDatatype;
// 队列结点
typedef struct QENode
{
QEDatatype data;
struct QENode* next;
}QENode;
// 队列
typedef struct Queue
{
QENode* phead; // 指向队头的指针
QENode* ptail; // 指向队尾的指针
int size; // 描述队列内元素个数
}QE;2.2：队列的各个功能实现
2.2.1：初始化队列
在没有操作队列时，队列的头指针和尾指针都应置为NULL，且size = 0。
2.2.2：队列进行判空
2.2.3：入对（对队列进行插入数据）
因为每次入队入的都是一个队列结点，所以入队之前应malloc出一个结点用来入队。并且入队时只能在队尾进行入队。入队后将队尾指针指向该队列新插入的一个结点（队尾结点）。
2.2.4：出队（删除队列元素）
出队之前要先对队列进行判空处理，然后将队头指针指向其下一个结点（注意：当该队列只有一个数据进行出队操作时，应将队头指针和队尾指针同时置为NULL）。
2.2.5：获取队头元素
2.2.6：获取队尾元素
2.2.7：获取队列内元素个数
2.2.8：销毁队列
2.3：队列实现的源代码
2.3.1：Queue_Func.h 代码实现
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
// 实现一个队列
typedef int QEDatatype;
typedef struct QENode
{
QEDatatype data;
struct QENode* next;
}QENode;
typedef struct Queue
{
QENode* phead;
QENode* ptail;
int size;
}QE;
// 判空
bool QE_Empty(QE* pqe);
// 初始化队列
void QE_Init(QE* pqe);
// 入队
void QE_Push(QE* pqe, QEDatatype x);
// 出队
void QE_Pop(QE* pqe);
// 获取队头元素
QEDatatype QE_Head(QE* pqe);
// 获取队尾元素
QEDatatype QE_Tail(QE* pqe);
// 获取队列元素个数
int QE_Size(QE* pqe);
// 销毁队列
void QE_Destroy(QE* pqe);2.3.2：Queue_Func.c 代码实现
#include"Queue_Func.h"
// 判空
bool QE_Empty(QE* pqe)
{
return pqe->size == 0;
}
// 初始化队列
void QE_Init(QE* pqe)
{
pqe->phead = pqe->ptail = NULL;
pqe->size = 0;
}
// 获取一个队列结点
QENode* Buy_Node(QEDatatype x)
{
QENode* newnode = (QENode*)malloc(sizeof(QENode));
if (newnode == NULL)
{
perror("Buy_Node malloc fail");
return NULL;
}
newnode->data = x;
newnode->next = NULL;
return newnode;
}
// 入队
void QE_Push(QE* pqe, QEDatatype x)
{
QENode* newnode = Buy_Node(x);
if (QE_Empty(pqe))
{
pqe->phead = pqe->ptail = newnode;
}
else
{
pqe->ptail->next = newnode;
pqe->ptail = newnode;
}
pqe->size++;
}
// 出队
void QE_Pop(QE* pqe)
{
assert(!QE_Empty(pqe));
QENode* cur = pqe->phead;
if (pqe->phead == pqe->ptail)
{
pqe->phead = pqe->ptail = NULL;
}
else
{
pqe->phead = cur->next;
}
free(cur);
pqe->size--;
}
// 获取队头元素
QEDatatype QE_Head(QE* pqe)
{
assert(!QE_Empty(pqe));
return pqe->phead->data;
}
// 获取队尾元素
QEDatatype QE_Tail(QE* pqe)
{
assert(!QE_Empty(pqe));
return pqe->ptail->data;
}
// 获取队列元素个数
int QE_Size(QE* pqe)
{
return pqe->size;
}
// 销毁队列
void QE_Destroy(QE* pqe)
{
QENode* cur = pqe->phead;
while (cur != pqe->ptail)
{
QENode* curnext = cur->next;
free(cur);
cur = curnext;
}
free(cur);
pqe->phead = pqe->ptail = NULL;
pqe->size = 0;
}2.3.3：Queue_Main.c 代码实现
#include"Queue_Func.h"
int main()
{
QE qn;
// 初始化队列
QE_Init(&qn);
// 插入数据
QE_Push(&qn, 1);
QE_Push(&qn, 2);
QE_Push(&qn, 3);
QE_Push(&qn, 4);
QE_Push(&qn, 5);
QE_Push(&qn, 6);
QE_Push(&qn, 7);
QE_Push(&qn, 8);
printf("数据元素个数：=> %d\n", QE_Size(&qn));
while (!QE_Empty(&qn))
{
printf("%d ", QE_Head(&qn));
QE_Pop(&qn);
}
// 销毁队列
QE_Destroy(&qn);
}运行结果：
扫一扫
816
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
