一、栈
1.栈的概念及结构
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据也在栈顶。
注意这里的栈是数据结构层次的栈,而系统栈是操作系统层次上的
两种栈的执行逻辑是同理的
系统栈是进程地址空间的划分,是给操作系统用的
而这里的栈是数据结构,是一种特殊的线性表
2.栈的实现
栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
// 下面是定长的静态栈的结构,实际中一般不实用,所以我们主要实现下面的支持动态增长的栈typedef int STDataType ;#define N 10typedef struct Stack{STDataType _a [ N ];int _top ; // 栈顶} Stack ;// 支持动态增长的栈typedef int STDataType ;typedef struct Stack{STDataType * a ;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 );// 检测栈是否为空,如果为空返回非零结果,如果不为空返回 0int StackEmpty ( Stack * ps );// 销毁栈void StackDestroy ( Stack * ps );
1.初始化栈
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->Capacity = ps->top = 0;
}
在初始化栈的时候要注意的是 代表栈顶元素下标的top 在初始化时有两种可能
一种就是初始化为-1 这样在压栈后top++,能够使得top就是栈顶元素的下标
另一种就是和栈容量capacity一样初始化为0,这样在压栈后top为栈顶元素的下一位
两种选择会使得其他接口实现时代码的差异,但是差异也不大,我这里选择初始化0
2.销毁栈
void StackDestory(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->Capacity = ps->top = 0;
}
3.入栈
void StackPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->Capacity == ps->top)
{
int newcapacity = ps->Capacity == 0 ? 4 : ps->Capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->a = tmp;
ps->Capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
4.出栈
void StackPop(ST* ps)
{
assert(ps);
ps->top--;
}
5.获取栈顶元素
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->top-1];
}
6.判断栈是否为空
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
7.获取栈元素个数
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
二、队列
1.队列的概念及结构
队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out)
入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头
2.队列的实现
队列也可以数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数组的结构,出队列在数组头上出数据,效率会比较低。
而为了减少内存等的一些消耗,我们选择使用单向链表,然后为了提高头尾操作的效率,我们可以定义一个链头和链尾,方便操作
// 链式结构:表示队列typedef struct QListNode{struct QListNode * next ;QDataType data ;} QNode ;// 队列的结构typedef struct Queue
{QNode * head ;QNode * tail ;} Queue ;// 初始化队列void QueueInit ( Queue * q );// 队尾入队列void QueuePush ( Queue * q , QDataType data );// 队头出队列void QueuePop ( Queue * q );// 获取队列头部元素QDataType QueueFront ( Queue * q );// 获取队列队尾元素QDataType QueueBack ( Queue * q );// 获取队列中有效元素个数int QueueSize ( Queue * q );// 检测队列是否为空,如果为空返回非零结果,如果非空返回 0int QueueEmpty ( Queue * q );// 销毁队列void QueueDestroy ( Queue * q );
1.初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
2.销毁队列
void QueueDestory(Queue* pq)
{
assert(pq);
QNode* cur = pq->head;
while (cur)
{
QNode* del = cur;
cur = cur->next;
free(del);
del = NULL;
}
pq->head = pq->tail = NULL;
}
3.队尾入队列
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
else
{
newnode->data = x;
newnode->next = NULL;
}
if (pq->head == NULL)
{
pq->head = pq->tail = newnode;
}
else
{
pq->tail->next = newnode;
pq->tail = newnode;
}
pq->size++;
}
4.队头出队列
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
if (pq->head->next == NULL)//为了避免head变为野指针的情况
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QNode* del = pq->head;
pq->head = pq->head->next;
free(del);
del = NULL;
}
pq->size--;
}
5.获取队头数据
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
6.获取队尾数据
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
7.判断队列是否为空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
8.获取队列元素个数
int QueueSize(Queue* pq)
{
assert(pq);
//QNode* cur = pq->head;
//int n = 0;
//while (cur)
//{
// ++n;
// cur = cur->next;
//}
//return n;
return pq->size;
}