目录
一:栈
1.1:栈的概念结构与实现
1.1.1:栈的概念结构
1.1.2:栈的实现
1.2:栈的各个功能实现
1.2.1:对栈进行初始化
1.2.2:判空栈
1.2.3:入栈
1.2.4:出栈
1.2.5:获取栈顶元素
1.2.6:获取栈内元素个数
1.2.7;销毁栈
1.3:栈的源代码
1.3.1:Stack _Func.h 代码实现
1.3.2:Stack _Func.c 代码实现
1.3.3:Stack _Main.c 代码实现
二:队列
2.1:队列的概念结构与实现
2.1.1:队列的概念及结构
2.2.2:队列的实现
2.2:队列的各个功能实现
2.2.1:初始化队列
2.2.2:队列进行判空
2.2.3:入对(对队列进行插入数据)
2.2.4:出队(删除队列元素)
2.2.5:获取队头元素
2.2.6:获取队尾元素
2.2.7:获取队列内元素个数
2.2.8:销毁队列
2.3:队列实现的源代码
2.3.1:Queue_Func.h 代码实现
2.3.2:Queue_Func.c 代码实现
2.3.3:Queue_Main.c 代码实现
一:栈
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);}
运行结果: