栈和队列
1.栈的定义
栈(stack)是限定仅在表尾进行插入和删除操作的线性表。
我们把允许数据插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出(Last In First Out)的线性表。
1.1栈的顺序存储结构
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
//支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; //栈顶下标
int _capacity;//容量
}Stack;
1.2基于动态数组实现的顺序栈
//初始化
void StackInit(Stack* pst)
{
assert(pst);
pst->_a = malloc(sizeof(STDataType) * 4);
pst->_top = 0;
pst->_capacity = 4;
}
//销毁
void StackDestory(Stack* pst)
{
assert(pst);
free(pst->_a);
pst->_a = NULL;
pst->_top = pst->_capacity = 0;
}
//入栈
void StackPush(Stack* pst, STDataType x)
{
assert(pst);
//判断栈是否满了
if (pst->_top == pst->_capacity)
{
//增容
pst->_capacity *= 2;
STDataType* temp = realloc(pst->_a, sizeof(STDataType) * pst->_capacity);
if (temp == NULL)
{
printf("内存不足\n");
exit(-1);
}
else
{
pst->_a = temp;
}
}
//数据入栈
pst->_a[pst->_top] = x;
pst->_top++;
}
//出栈
void StackPop(Stack* pst)
{
assert(pst);
assert(pst->_top > 0);
--pst->_top;
}
//获取数据个数
int StackSize(Stack* pst)
{
assert(pst);
return pst->_top;
}
//返回1是空 返回0是非空
int StackEmpty(Stack* pst)
{
assert(pst);
//return pst->_top == 0 ? 1 : 0;
return !pst->_top;
}
//获取栈顶的数据
STDataType StackTop(Stack* pst)
{
assert(pst);
assert(pst->_top > 0);
return pst->_a[pst->_top - 1];
}
2.队列的定义
队列(queue)是只允许在一端进行插入操作，另一端进行删除操作的线性表。
队列是一种先进先出(First In First Out )的线性表，允许插入的一段称为队尾，允许删除的一端称为队头。
2.1队列的链式存储结构
队列也可以用数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低 。
//链式结构表示队列
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* _next;
QDataType _data;
}QueueNode;
//队列的结构
typedef struct Queue
{
QueueNode* _head;//队头
QueueNode* _tail;//队尾
}Queue;
2.2基于单链表实现的链队列
//初始化队列
void QueueInit(Queue* pq)
{
assert(pq);
pq->_head = pq->_tail = NULL;
}
//销毁队列
void QueueDestory(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->_head;
while (cur)
{
QueueNode* next = cur->_next;
free(cur);
cur = next;
}
pq->_head = pq->_tail = NULL;
}
//队尾入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
//申请新空间
QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
if (newNode == NULL)
{
printf("内存不足\n");
exit(-1);
}
newNode->_data = x;
newNode->_next = NULL;
//判空
if (pq->_head == NULL)
{
pq->_head = pq->_tail = newNode;
}
else
{
//不为空插入队尾，将队尾指针重置
pq->_tail->_next = newNode;
pq->_tail = newNode;
}
}
//队头出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(pq->_head);
//释放队头使其指向下一个结点
QueueNode* next = pq->_head->_next;
free(pq->_head);
pq->_head = next;
//判断只剩一个元素的时候
if (pq->_head == NULL)
{
pq->_tail = NULL;
}
}
//取队头元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->_head);
return pq->_head->_data;
}
//取队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->_tail);
return pq->_tail->_data;
}
//返回1是空 返回0是非空
int QueueEmpty(Queue* pq)
{
assert(pq);
return pq->_head == NULL ? 1 : 0;
}
//获取数据个数
int QueueSize(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->_head;
int size = 0;//计数
while (cur)
{
++size;
cur = cur->_next;
}
return size;
}