一、栈
1、栈的概念及结构
栈是一种特殊的线性表,其中只允许在固定的一端进行插入和删除元素的操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈:栈的插入操作叫做压栈/进栈/入栈,入数据在栈顶
出栈:栈的删除操作叫做出栈,出数据也在栈顶。
2、栈的实现
栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
下面实现动态增长的栈
#define MAX_SIZE 3
#define INC_SIZE 10
typedef int DataType;
typedef struct Stack
{
DataType* arr;
int capacity; //容量
int size; //有效元素个数
}Stack;
//扩容函数
static void _IncCapacity(Stack* s)
{
assert(s != NULL);
//申请新空间
DataType* tmp = (DataType*)malloc(sizeof(DataType) * (s->capacity + INC_SIZE));
if (tmp == NULL)
{
printf("IncCapacity:malloc失败\n");
exit(0);
}
//将旧空间的值拷贝到新空间中
memcpy(tmp, s->arr, sizeof(DataType) * s->size);
//释放旧空间,并指向新空间
free(s->arr);
s->arr = tmp;
s->capacity += INC_SIZE;
}
//初始化栈
void StackInit(Stack* s)
{
assert(s != NULL);
s->arr = (DataType*)malloc(sizeof(DataType) * MAX_SIZE);
if (s->arr == NULL)
{
printf("StackInit:malloc失败\n");
exit(0);
}
s->capacity = MAX_SIZE;
s->size = 0;
}
//入栈
void StackPush(Stack* s, DataType data)
{
assert(s != NULL);
if (s->size == s->capacity)
_IncCapacity(s);
s->arr[s->size] = data;
s->size++;
}
//出栈
void StackPop(Stack* s)
{
assert(s != NULL);
if (StackEmpty(s))
return;
s->size--;
}
//获取栈顶元素
DataType StackGetTop(Stack* s)
{
assert(s != NULL);
assert(s->size != 0);
return s->arr[s->size - 1];
}
//获取栈内有效元素个数
int StackSize(Stack* s)
{
assert(s != NULL);
return s->size;
}
//检测栈是否为空,为空返回非0,不为空返回0
int StackEmpty(Stack* s)
{
assert(s != NULL);
return s->size == 0;
}
//销毁栈
void StackDestroy(Stack* s)
{
assert(s != NULL);
free(s->arr);
s->arr = NULL;
s->capacity = 0;
s->size = 0;
}
//打印栈
void StackPrint(Stack* s)
{
assert(s != NULL);
for (int i = 0; i < s->size; ++i)
printf("%d ", s->arr[i]);
printf("\n");
}
二、队列
1、队列的概念及结构
队列是只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表。队列具有先进先出FIFO(First In First Out)的原则。
入队:进行插入操作的一端称为队尾
出队:进行删除操作的一端称为队头
2、队列的实现
队列也可以用数组或链表的结构实现,使用链表的结构更优一些,因为如果使用数组的结构,出队列在数据头上出数据,效率会比较低。
代码实现
typedef int DataType;
//链式结构:表示队列
typedef struct QNode
{
DataType data;
struct QNode* next;
}QNode;
//队列结构
typedef struct Queue
{
QNode* front;
QNode* back;
}Queue;
//申请节点
static QNode* _BuyQNode(DataType data)
{
QNode* newNode = (QNode*)malloc(sizeof(QNode));
if (newNode == NULL)
{
printf("_BuyQNode:malloc失败\n");
exit(0);
}
newNode->data = data;
newNode->next = NULL;
return newNode;
}
//初始化队列
void QueueInit(Queue* q)
{
assert(q != NULL);
q->front = NULL;
q->back = NULL;
}
//入队
void QueuePush(Queue* q, DataType data)
{
assert(q != NULL);
QNode* newNode = _BuyQNode(data);
if (QueueEmpty(q))
{
//队列为空
q->front = newNode;
q->back = newNode;
}
else
{
//队列不为空
q->back->next = newNode;
q->back = newNode;
}
}
//出队
void QueuePop(Queue* q)
{
assert(q != NULL);
if (QueueEmpty(q))
{
//队为空
return;
}
else
{
QNode* delNode = q->front;
q->front = q->front->next;
free(delNode);
//队列只有一个元素时
if (q->front == NULL)
q->back = NULL;
}
}
//获取队列头部元素
DataType QueueGetFront(Queue* q)
{
assert(q != NULL);
assert(q->front != NULL);
return q->front->data;
}
//获取队列尾部元素
DataType QueueGetBack(Queue* q)
{
assert(q != NULL);
assert(q->back != NULL);
return q->back->data;
}
//获取队列有效元素个数
int QueueSize(Queue* q)
{
assert(q != NULL);
QNode* pcur = q->front;
int cnt = 0;
while (pcur != NULL)
{
cnt++;
pcur = pcur->next;
}
return cnt;
}
//检测队列是否为空。为空返回非0,不为空返回0
int QueueEmpty(Queue* q)
{
assert(q != NULL);
return q->front == NULL;
}
//销毁队列
void QueueDestroy(Queue* q)
{
assert(q != NULL);
QNode* pcur = q->front;
while (pcur != NULL)
{
q->front = q->front->next;
free(pcur);
pcur = q->front;
}
}
//打印队列
void QueuePrint(Queue* q)
{
assert(q != NULL);
QNode* pcur = q->front;
while (pcur != NULL)
{
printf("%d ", pcur->data);
pcur = pcur->next;
}
printf("\n");
}