数据结构——栈和队列

---

前言

在之前的函数栈桢文章中，我们提到了栈。对此，大家可能有些许的困惑，今天我们来系统的了解一下。

---

一、栈

1.1栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。

1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
以下是分别用链表和数组实现栈的示意图：

栈分为静态和动态，在实际中静态栈一般不实用，所以我主要介绍下面的支持动态增长的栈

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); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps); 
// 销毁栈
void StackDestroy(Stack* ps); 

具体的代码我放入我的gitte中了，大家感兴趣的可以看一看
https://gitee.com/brave-zhu/c-language/commit/29e4f82b9679da7c45d7b3ec667bf6dbb2d29313

二、队列

2.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头。

2.2队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

// 链式结构：表示队列
typedef struct QListNode
{ 
 struct QListNode* _pNext; 
 QDataType _data; 
}QNode; 
// 队列的结构
typedef struct Queue
{ 
  QNode* _front; 
  QNode* _rear; 
}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); 
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q); 
// 销毁队列
void QueueDestroy(Queue* q);

具体的代码我放入我的gitte中了，大家感兴趣的可以看一看
https://gitee.com/brave-zhu/c-language/commit/149c1f787ff76bc72fad33f5d88706007264db55

2.3循环队列

在实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。
数组实现：

链表实现

三、oj题

3.1括号匹配问题

https://leetcode.cn/problems/valid-parentheses/description/
这道题目实际上就是通过栈来实现，左括号先进栈，遇到右括号出栈判断。

typedef char STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}Stack;
void StackInit(Stack* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);
    if (ps->top == ps->capacity)
    {
        int newcapacity = ps->capacity == 0?4 :(ps->capacity * 2);
        STDataType* newStack = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
        if (newStack == NULL)
        {
            perror("realloc fail");
            exit(-1);
        }
        ps->a = newStack;
        ps->capacity = newcapacity;
    }
    ps->a[ps->top] = data;
    ps->top++;
}
void StackPop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}
STDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top-1];
}
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->top;
}
bool StackEmpty(Stack* ps)
{
    assert(ps);
    return ps->top== 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
bool isValid(char * s){
    Stack st;
    StackInit(&st);
    char val=0;
    while(*s)
    {
        //左括号进栈
        if(*s=='('||*s=='['||*s=='{')
        {
             StackPush(&st, *s); 
        }
        else
        {
           //数量不匹配
           if(StackEmpty(&st))
           {
               StackDestroy(&st);
               return false;
           }
           val=StackTop(&st);
           StackPop(&st);
           //格式不匹配
           if((*s==')'&&val!='(')||(*s=='}'&&val!='{')||(*s==']'&&val!='['))
           {
               StackDestroy(&st);
               return false;
           }
        }
        s++;
    }
    //数量是否匹配
    bool ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

3.2循环队列

https://leetcode-cn.com/problems/design-circular-queue/
本题目涉及到了循环队列，我们通过数组来实现。本质上要关注的问题是：

• 判断空队列 front==rear

• 判断满队列 (rear+1)%(k+1)==front

• push时，rear值变化 rear%=(k+1)

• pop时，front值变化 front%=(k+1)

typedef struct
 {
    int* a;
    int front;
    int rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k)
 {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->front=obj->rear=0;
    obj->k=k;
    return obj;
}
//判断是否空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
     return obj->rear==obj->front;
       
}
//判断是否满
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
     return (obj->rear+1)%(obj->k+1)==obj->front;
     
}
//队尾插入元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->rear]=value;
        obj->rear++;
        obj->rear%=(obj->k+1);
        return true;
    }
}
//队头删除元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        ++obj->front;
        obj->front%=(obj->k+1);
        return true;
    }
}
//队首元素
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(!myCircularQueueIsEmpty(obj))
    {
       return obj->a[obj->front];
    }
    else
    {
        return -1;
    }
}
//队尾元素
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(!myCircularQueueIsEmpty(obj))
    {
         return obj->a[(obj->rear+obj->k)%(obj->k+1)];
    }
    else
    {
        return -1;
    }
}
//销毁
void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}

四、总结

以上就是我对于栈和队列的理解，文章还有许多不足，大家多多包涵，如果有对于文章有不理解的地方可以在下方评论一下，或者后台私信我。最后记得三连哦，谢谢支持！