手撕数据结构---栈和队列的概念以及实现

凯子坚持 c

于 2024-07-30 09:56:19 发布

阅读量258

点赞数 29

分类专栏：数据结构文章标签：数据结构 java 开发语言

本文链接：https://blog.csdn.net/2301_80863610/article/details/140761108

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

栈的概念：

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

压栈：栈的插⼊操作叫做进栈/压栈/⼊栈，⼊数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

栈的基本框架

struct Stack
{
    int* arr;
    int capacity;
    int top;//栈顶
};

栈的实现

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void STTest()
{
    ST st;//创建一个栈变量

    //初始化
    STInit(&st);

    //入栈
    SrackPush(&st, 1);
    SrackPush(&st, 2);
    SrackPush(&st, 3);
    SrackPush(&st, 4);
    SrackPush(&st, 5);
    //打印栈内的有效数据
    printf("%d\n", STSize(&st));
    //栈的出数据
    /*SrackPop(&st);*/
    //循环出栈，直到栈为空
    // 
    while (!StackEmpty(&st))//如果栈不为空的话，我们一直进行循环打印栈顶数据
    {
        //取出当前栈顶的数据
        STDataType data = StackTop(&st);
        printf("%d ", data);//打印返回的栈顶数据
        //数据出栈
        SrackPop(&st);

        //入栈的顺序是1 2 3 4 5
        //出栈的顺序是5 4 3 2 1

        //栈是不能被遍历的，也不能被随机访问
    }
    //打印栈内的有效数据
    printf("%d\n", STSize(&st));


    //销毁
    STDestory(&st);
}

int main()
{
    STTest();
    return 0;
}
//栈这样的结构只能在一端入栈，一端出栈

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

//初始化
void STInit(ST* ps)
{
    assert(ps);//判断传的ps是不是空的
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
    //一开始的栈顶等于我们的栈底（栈为空的话）
}

//销毁
void STDestory(ST* ps)
{
    assert(ps);//参数不能传空

    if (ps->arr)//arr不为空的话我们直接将数组释放掉
    {
        free(ps->arr);
    }
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
}





//栈的入数据操作
void SrackPush(ST* ps, STDataType x)
{
    assert(ps);//ps不能传空

    //如果空间足够的话我们直接进行插入

    //判断空间是否足够，如果top等于capacity的话，那么就说明我们这个栈就是满的
    if (ps->capacity == ps->top)//，满了，我们需要进行增容操作
    {
        //二倍的增加
        //初始情况下我们的capacity是定义为0的，所以我们不能直接进行乘二的操作
        //我们需要创建一个变量
        int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        //如果容量为0的话，我们给newCapacity一个初始值4，如果不为0我们就进行乘二的操作

        STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        //申请成功，我们将tmp申请的空间给pa->arr
        ps->arr = tmp;

        //申请空间成功了，那么我们就要将capacity进行改变了
        ps->capacity = newCapacity;
    }

    //到这里空间一定是够的
    ps->arr[ps->top] = x;//我们往栈顶的位置进行添加数据
    //添加完数据之后，top要加加
    ps->top++;
}

//判断栈是否为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;//为空就返回true
}

//栈的出数据操作
void SrackPop(ST* ps)
{
    assert(ps);
    //如果栈为空的话，我们是不能出数据的（top==0）
    assert(!StackEmpty(ps));//如果栈为空就会报错了

    //走到这里就说明栈不为空
    --ps->top;//我们只需要将top进行--操作就能进行栈的出数据操作了
}


//取栈顶元素---循环打印栈顶的数据
STDataType StackTop(ST* ps)//返回值是栈顶的元素
{
    assert(ps);

    assert(!StackEmpty(ps));//判断当前栈是不是空的，如果是空的话，我们没有什么能取的

    return ps->arr[ps->top - 1];//ps->top - 1是这个栈的最后一个数据的下标

}

//获取栈中有效个数
int STSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>


//定义栈的结构
typedef int STDataType;
typedef struct Stack
{
    STDataType* arr;
    int capacity;//栈的空间大小
    int top;//栈顶（插入数据和删除数据的位置）
}ST;

//初始化
void STInit(ST* ps);//传的是地址

//销毁
void STDestory(ST* ps);

//栈顶-=--如数据、出数据

//栈的入数据操作
void SrackPush(ST* ps, STDataType x);//第二个参数是要插入的数据

//栈的出数据操作
void SrackPop(ST* ps);

//取栈顶元素---循环打印栈顶的数据
STDataType StackTop(ST* ps);//返回值是栈顶的元素

//判断栈是否为空
bool StackEmpty(ST* ps);

//获取栈中有效个数
int STSize(ST* ps);

队列的概念

概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)

⼊队列：进⾏插⼊操作的⼀端称为队尾

出队列：进⾏删除操作的⼀端称为队头

队头：用来删除数据

对头：用来插入数据

队列的底层是链表，链表是由一个一个的节点组成

//定义队列节点的结构
struct QueueNode
{
    int data;
    struct QueueNode* next;//指向下个节点的指针
};

struct Queue
{
    struct QueueNode* phead;//指向的是队头--删除数据
    struct QueueNode* ptail;//指向的是队尾--插入数据
};

为什么是定义的是两个结构体类型呢？

队列中的每一个数据是通过一个节点保存的，节点和节点之间是通过指针链接的，

其实就是维护了一个链表，给这个链表加上先进先出的限制，其实就是队列了

Queue.h

#pragma once
#include <stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>


//定义队列结构
typedef int QDataType;
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;

}QueueNode;

typedef struct Queue
{
    QueueNode*phead;//指向头节点的指针---队头--删除数据
    QueueNode*ptail;//指向尾节点的指针---队尾--插入数据
    int size;//保存队列有效个数
}Queue ;


//初始化
void QueueInit(Queue* pq);

//入队列，队尾   插入数据
void QueuePush(Queue* pq, QDataType x);

//出队列,队头    删除数据
void QueuePop(Queue* pq);

//判断队列是否为空
bool Queuempty(Queue* pq);

//取队头数据
QDataType QueueFront(Queue* pq);

//取队尾数据
QDataType QueueBack(Queue* pq);

//队列有效元素个数
int QueueSize(Queue* pq);

//队列的销毁
void QueueDestroy(Queue* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

//初始化
void QueueInit(Queue* pq)
{
    assert(pq);//传过来的不能是空指针 

    pq->phead = pq->ptail = NULL;//空的队列
    pq->size = 0;
}

//判断队列是否为空
bool Queuempty(Queue* pq)
{
    assert(pq);

    return pq->phead == NULL && pq->ptail == NULL;
    //如果后面的表达式成立，那么就是真，返回的是true

    //就是说如果这里的是空队列的话，那么就返回的是true
}

//入队列，队尾   插入数据
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);

    //申请新节点
    QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));//申请一个节点大小的空间
    if (newnode == NULL)
    {
        perror("malloc dail!");
        exit(1);
    }
    //对newnode进行初始化操作
    newnode->data = x;
    newnode->next = NULL;
    if (pq->phead == NULL)//说明队列为空
    {
        pq->phead = pq->ptail = newnode;//那么此时的newnode不仅是头结点也是尾节点
    }
    else//队列不为空
    {
        pq->ptail->next = newnode;
        //那么此时的newnode 就是新的ptail
        pq->ptail = newnode;
    }
    pq->size++;
}

//出队列,队头    删除数据    从头结点开始删除数据
void QueuePop(Queue* pq)
{
    assert(pq);
    //队列为空（不可删除数据，因为没有数据）
    //队列不为空（可删除数据）

    assert(!Queuempty(pq));//队列为空白的话就报错

    //处理只有一个节点的情况，避免ptail变成野指针
    //判断只有一个节点的情况
    if (pq->ptail == pq->phead)//头尾指针相同，说明只有一个节点
    {
        free(pq->phead);//随便释放
        pq->phead = pq->ptail = NULL;
    }
    else//处理多个节点的情况
    {
        //删除队头元素
    //那么我们现将下个节点的位置进行保存
        QueueNode* next = pq->phead->next;
        //存储好之后我们直接将头结点进行释放
        free(pq->phead);
        pq->phead = next;//那么之前存的next就是新的头结点了
    }
    pq->size--;
}

//取队头数据
QDataType QueueFront(Queue* pq)//返回队头数据
{
    assert(pq);
    assert(!Queuempty(pq));//队列不为空

    return pq->phead->data;//将队头里面的数据直接返回就行了
}

//取队尾数据
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!Queuempty(pq));//队列不为空

    return pq->ptail->data;
}

//队列有效元素个数
int QueueSize(Queue* pq)
{
    assert(pq);
    //下面这种遍历的话效率太低了
    //int size = 0;
    定义一个指针进行遍历
    //QueueNode* pcur = pq->phead;//指向队列的头结点
    //while (pcur)//pcur不为空就往后走
    //{
    //  size++;
    //  pcur = pcur->next;
    //}
    //return size;
    return pq->size;
}

//队列的销毁
void QueueDestroy(Queue* pq)
{
    assert(pq);
    assert(!Queuempty(pq));//队列不为空
    //遍历
    QueueNode* pcur = pq->phead;
    while (pcur)
    {
        //销毁之前先把下个节点进行保存
        QueueNode* next = pcur -> next;
        free(pcur);
        //将Pcur销毁之后，那么之前保存的next就是新的头结点
        pcur = next;
    }
    pq->phead = pq->ptail = NULL;
    pq->size = 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"


void QueueTest01()
{
    Queue q;//创建一个队列变量
    //初始化
    QueueInit(&q);

    //插入数据
    QueuePush(&q, 1);
    QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 4);

    //取队头数据
    printf("head:%d\n", QueueFront(&q));

    //取队尾数据
    printf("tail:%d\n", QueueBack(&q));

    //删除
    QueuePop(&q);

    //队列有效个数
    printf("size:%d\n", QueueSize(&q));

    //队列的销毁
    QueueDestroy(&q);

}
int main()  
{
    QueueTest01();
}

栈和队列相关的OJ题

题目一：有效的括号

//借助数据结构---栈来解决这道题
/*
思路：我们先创建一个字符串指针ps
我们再创建一个栈空间
我们通过ps进行字符串的遍历
如果是做左括号的话，那么我们就进行入栈操作
如果我们遇到了右括号的话，那么我们就与栈顶的元素进行匹配
 如果是一对括号的话，那么我们就进行出栈操作，然后ps++,top-- 进行下一对括号的匹配
 如果ps++指向的是大括号，但是栈顶的是小括号，那么现在就是不匹配的
 那么我们就直接返回false


*/
typedef char STDataType;
typedef struct Stack
{
    STDataType* arr;
    int capacity;
    int top;//栈顶
}ST;

//初始化
void STInit(ST* ps)
{
    assert(ps);//判断传的ps是不是空的
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
    //一开始的栈顶等于我们的栈底（栈为空的话）
}

//销毁
void STDestory(ST* ps)
{
    assert(ps);//参数不能传空

    if (ps->arr)//arr不为空的话我们直接将数组释放掉
    {
        free(ps->arr);
    }
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
}

//栈的入数据操作
void SrackPush(ST* ps, STDataType x)
{
    assert(ps);//ps不能传空

    //如果空间足够的话我们直接进行插入

    //判断空间是否足够，如果top等于capacity的话，那么就说明我们这个栈就是满的
    if (ps->capacity == ps->top)//，满了，我们需要进行增容操作
    {
        //二倍的增加
        //初始情况下我们的capacity是定义为0的，所以我们不能直接进行乘二的操作
        //我们需要创建一个变量
        int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        //如果容量为0的话，我们给newCapacity一个初始值4，如果不为0我们就进行乘二的操作

        STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        //申请成功，我们将tmp申请的空间给pa->arr
        ps->arr = tmp;

        //申请空间成功了，那么我们就要将capacity进行改变了
        ps->capacity = newCapacity;
    }

    //到这里空间一定是够的
    ps->arr[ps->top] = x;//我们往栈顶的位置进行添加数据
    //添加完数据之后，top要加加
    ps->top++;
}

//判断栈是否为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;//为空就返回true
}

//栈的出数据操作
void SrackPop(ST* ps)
{
    assert(ps);
    //如果栈为空的话，我们是不能出数据的（top==0）
    assert(!StackEmpty(ps));//如果栈为空就会报错了

    //走到这里就说明栈不为空
    --ps->top;//我们只需要将top进行--操作就能进行栈的出数据操作了
}


//取栈顶元素---循环打印栈顶的数据
STDataType StackTop(ST* ps)//返回值是栈顶的元素
{
    assert(ps);

    assert(!StackEmpty(ps));//判断当前栈是不是空的，如果是空的话，我们没有什么能取的

    return ps->arr[ps->top - 1];//ps->top - 1是这个栈的最后一个数据的下标

}

//获取栈中有效个数
int STSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

bool isValid(char* s)
{
    ST st;//创建一个栈变量
    //初始化
    STInit(&st);


    //遍历字符串s
    char *ps=s;//指向字符串s
    while(*ps!='\0')//我们需要遍历字符串'\0'之前的数据
    {
        //左括号入栈
        if(*ps=='('|| *ps=='[' || *ps=='{')
        {
            SrackPush(&st,*ps);
        }
        else//右括号，和栈顶元素进行匹配
        {
            //栈不为空才能取元素
            //判断栈是否为空，空的话直接返回false
            if(StackEmpty(&st))//栈为空的话，这个函数返回的就是true
            {
                return false;
            }
            //取栈顶元素，与top进行比较
            char ch=StackTop(&st);//栈顶的元素，我们取出
            if((*ps==')' &&ch=='(')
            ||(*ps==']' &&ch=='[')
            ||(*ps=='}' &&ch=='{'))
            {
                //匹配上了我们就进行出栈操作
                SrackPop(&st);
            }
            else
            {
                //不匹配的话，我们在返回之前我们同样需要进行销毁操作
                STDestory(&st);
                //那么就是括号不匹配了
                return false;
            }
        }
        //入栈之后我们进行ps++
        ps++;

    }
    bool ret=StackEmpty(&st)==true;//为空的话那么我们就返回truew
    //销毁
    STDestory(&st);
    return ret;
}
/*
假如我们的字符串里面只有一个左括号的话，那么这个代码就会直接入栈
然后跳出循环，并没有对栈内的空间进行检查 
并没有进行出栈的操作，所以栈内是有元素的
我们要判断栈内是否为空
如果是空的话，那么就说括号都配对完成了，左括号都出栈了，那么就返回true

*/
/*
我们在取栈顶元素之前我们还要对栈的空间进行判断，看看栈是否为空，
栈不为空才能去栈顶元素
栈为空的话，之间返回false

*/

题目二:用队列实现栈

/*
队列是先进先出
栈是先进后出
*/
/*
因为我们是要进行栈的实现
那么假如我们存进去1 2 3
那么拿出来的就是3 2 1

我们用两个队列实现
Q1和Q2两个队列
假设现在Q1里面的是1 2 3,1在对头，3在队尾
我们Q1每次出size-1个数据入到Q2里面，那么此时的Q1就剩下一个3,那么我们直接将3出栈，那么得到的第一个数就是3
以此类推我们就能得到3 2 1
*/

/*
两个队列，那个队列不为空，我们就将这个队列里面的size-1个数据导入到另一个队列里面去，然后将剩下的元素导出了

如果最后队列里面只有一个数据，那么我们就直接将这个数据导出
*/

/*思路：
出栈：找到不为空的队列，将size-1个数据导入到另一个队列中
入栈：往空队列中插入数据
取栈顶元素


*/

//定义队列结构
typedef int QDataType;
typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;

}QueueNode;

typedef struct Queue
{
    QueueNode*phead;//指向头节点的指针---队头--删除数据
    QueueNode*ptail;//指向尾节点的指针---队尾--插入数据
    int size;//保存队列有效个数
}Queue ;

//初始化
void QueueInit(Queue* pq)
{
    assert(pq);//传过来的不能是空指针 

    pq->phead = pq->ptail = NULL;//空的队列
    pq->size = 0;
}

//判断队列是否为空
bool Queuempty(Queue* pq)
{
    assert(pq);

    return pq->phead == NULL && pq->ptail == NULL;
    //如果后面的表达式成立，那么就是真，返回的是true

    //就是说如果这里的是空队列的话，那么就返回的是true
}

//入队列，队尾   插入数据
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);

    //申请新节点
    QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));//申请一个节点大小的空间
    if (newnode == NULL)
    {
        perror("malloc dail!");
        exit(1);
    }
    //对newnode进行初始化操作
    newnode->data = x;
    newnode->next = NULL;
    if (pq->phead == NULL)//说明队列为空
    {
        pq->phead = pq->ptail = newnode;//那么此时的newnode不仅是头结点也是尾节点
    }
    else//队列不为空
    {
        pq->ptail->next = newnode;
        //那么此时的newnode 就是新的ptail
        pq->ptail = newnode;
    }
    pq->size++;
}

//出队列,队头    删除数据    从头结点开始删除数据
void QueuePop(Queue* pq)
{
    assert(pq);
    //队列为空（不可删除数据，因为没有数据）
    //队列不为空（可删除数据）

    assert(!Queuempty(pq));//队列为空白的话就报错

    //处理只有一个节点的情况，避免ptail变成野指针
    //判断只有一个节点的情况
    if (pq->ptail == pq->phead)//头尾指针相同，说明只有一个节点
    {
        free(pq->phead);//随便释放
        pq->phead = pq->ptail = NULL;
    }
    else//处理多个节点的情况
    {
        //删除队头元素
    //那么我们现将下个节点的位置进行保存
        QueueNode* next = pq->phead->next;
        //存储好之后我们直接将头结点进行释放
        free(pq->phead);
        pq->phead = next;//那么之前存的next就是新的头结点了
    }
    pq->size--;
}

//取队头数据
QDataType QueueFront(Queue* pq)//返回队头数据
{
    assert(pq);
    assert(!Queuempty(pq));//队列不为空

    return pq->phead->data;//将队头里面的数据直接返回就行了
}

//取队尾数据
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!Queuempty(pq));//队列不为空

    return pq->ptail->data;
}

//队列有效元素个数
int QueueSize(Queue* pq)
{
    assert(pq);
    //下面这种遍历的话效率太低了
    //int size = 0;
    定义一个指针进行遍历
    //QueueNode* pcur = pq->phead;//指向队列的头结点
    //while (pcur)//pcur不为空就往后走
    //{
    //  size++;
    //  pcur = pcur->next;
    //}
    //return size;
    return pq->size;
}

//队列的销毁
void QueueDestroy(Queue* pq)
{
    assert(pq);
    //assert(!Queuempty(pq));//队列不为空
    //遍历
    QueueNode* pcur = pq->phead;
    while (pcur)
    {
        //销毁之前先把下个节点进行保存
        QueueNode* next = pcur -> next;
        free(pcur);
        //将Pcur销毁之后，那么之前保存的next就是新的头结点
        pcur = next;
    }
    pq->phead = pq->ptail = NULL;
    pq->size = 0;
}



//两个队列来实现栈
typedef struct 
{
    Queue q1;//队列1
    Queue q2;//队列2
} MyStack;

//STInit  栈的初始化
MyStack* myStackCreate()
{
    MyStack*pst=(MyStack*)malloc(sizeof(MyStack));//创建一个栈大小的空间
    QueueInit(&pst->q1);//调用初始化函数对q1进行初始化
    QueueInit(&pst->q2);

    return pst;
}

//那么到这里我们有一个空栈，栈里面有两个队列

//入数据
void myStackPush(MyStack* obj, int x)
{
    //往不为空的队列插入数据
    //第一步判断那个队列是非空队列
    if(!Queuempty(&obj->q1))//如果这个队列不是空的话，我们就我那个这个队列里面入数据
    {
        //往队列内插入数据
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }

}
//出数据
int myStackPop(MyStack* obj)
{
    //找到不为空的队列
    Queue*empQ=&obj->q1;//假设q1是空的，创建指针指向q1
    Queue*noneQ=&obj->q2;//q2不为空，指针指向q2

    if(!Queuempty(&obj->q1))//如果q1不为空
    {
        //创建两个指针，noneQ指向的是非空队列，empQ指向的是空队列
        noneQ=&obj->q1;//那么这个非空指针就指向了q1
        empQ=&obj->q2;//那么空指针就指向q2了
    }
    //将不为空内的size-1个数据导入到另一个队列里面
    while(QueueSize(noneQ)>1)//循环条件是非空队列里面只剩下一个有效的数据了
    {
        int front=QueueFront(noneQ);//获取这个非空队列里面的队头数据
        QueuePush(empQ,front);//往空队列里面循环插入队头数据
        QueuePop(noneQ);//因为我们这个非空队列的队头数据已经拿出去了 ，那么我们就将非空队列进行删除数据操作
    }
    //非空队列中只剩下一个数据----那么这个数据就是要出栈的数据
    int pop=QueueFront(noneQ);//获取剩下的这个元素
    QueuePop(noneQ);//进行出数据操作
    return pop;//返回我们要的值

}

//取栈顶元素  假设插入1 2 3，那么栈顶就是3   这里是2两个队列
int myStackTop(MyStack* obj)   
{
    //找到不为空的队列，取队尾元素
    if(!Queuempty(&obj->q1))//如果第一个队列不为空的话
    {
        return QueueBack(&obj->q1);//直接将取到的队尾元素进行返回就行了
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}
//判读栈是否为空
bool myStackEmpty(MyStack* obj)
{
    //两个队列如果都为空的话，那么这个栈就是空的
    return Queuempty(&obj->q1)  &&  Queuempty(&obj->q2);
}
//销毁
void myStackFree(MyStack* obj)
{
    //就是栈内的连个队列的销毁
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);//将我们之前申请的栈空间进行释放掉
    obj=NULL;
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);

 * int param_2 = myStackPop(obj);

 * int param_3 = myStackTop(obj);

 * bool param_4 = myStackEmpty(obj);

 * myStackFree(obj);
*/

题目三：用栈实现队列

//定义栈的结构
typedef int STDataType;
typedef struct Stack
{
    STDataType* arr;
    int capacity;//栈的空间大小
    int top;//栈顶（插入数据和删除数据的位置）
}ST;

//初始化
void STInit(ST* ps)
{
    assert(ps);//判断传的ps是不是空的
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
    //一开始的栈顶等于我们的栈底（栈为空的话）
}

//销毁
void STDestory(ST* ps)
{
    assert(ps);//参数不能传空

    if (ps->arr)//arr不为空的话我们直接将数组释放掉
    {
        free(ps->arr);
    }
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
}





//栈的入数据操作
void SrackPush(ST* ps, STDataType x)
{
    assert(ps);//ps不能传空

    //如果空间足够的话我们直接进行插入

    //判断空间是否足够，如果top等于capacity的话，那么就说明我们这个栈就是满的
    if (ps->capacity == ps->top)//，满了，我们需要进行增容操作
    {
        //二倍的增加
        //初始情况下我们的capacity是定义为0的，所以我们不能直接进行乘二的操作
        //我们需要创建一个变量
        int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        //如果容量为0的话，我们给newCapacity一个初始值4，如果不为0我们就进行乘二的操作

        STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            perror("realloc fail!");
            exit(1);
        }
        //申请成功，我们将tmp申请的空间给pa->arr
        ps->arr = tmp;

        //申请空间成功了，那么我们就要将capacity进行改变了
        ps->capacity = newCapacity;
    }

    //到这里空间一定是够的
    ps->arr[ps->top] = x;//我们往栈顶的位置进行添加数据
    //添加完数据之后，top要加加
    ps->top++;
}

//判断栈是否为空
bool StackEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;//为空就返回true
}

//栈的出数据操作
void SrackPop(ST* ps)
{
    assert(ps);
    //如果栈为空的话，我们是不能出数据的（top==0）
    assert(!StackEmpty(ps));//如果栈为空就会报错了

    //走到这里就说明栈不为空
    --ps->top;//我们只需要将top进行--操作就能进行栈的出数据操作了
}


//取栈顶元素---循环打印栈顶的数据
STDataType StackTop(ST* ps)//返回值是栈顶的元素
{
    assert(ps);

    assert(!StackEmpty(ps));//判断当前栈是不是空的，如果是空的话，我们没有什么能取的

    return ps->arr[ps->top - 1];//ps->top - 1是这个栈的最后一个数据的下标

}

//获取栈中有效个数
int STSize(ST* ps)
{
    assert(ps);
    return ps->top;
}

///


/*
因为我们是用两个栈来实现队列
那么假如我们插入1 2 3 
那么导出的也是1 2 3


 我们创建两个栈，分别用来入数据和出数据
 第一个栈接入我们放的是1 2 3  1在栈底，3在栈顶
 那么我们将这三个数据依次放到另一个栈内
 那么另一个栈就是3 2 1  3在栈第，1在栈顶，那么我们依次将这个栈的数据依次导出
 就能达到队列的效果了
*/

/*逻辑：pop是出数据
入队：往pushST中插入数据

出队：判断popST是否为空，不为空直接pop,为空的话将pushST导入到popST中

 取队头：跟出队一样的，但是这里不pop数据
*/
typedef struct
{
    ST pushST;//两个栈
    ST popST;
} MyQueue;

//初始化操作
MyQueue* myQueueCreate()
{
    MyQueue*pst=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&pst->pushST);//栈的初始化
    STInit(&pst->popST);
    return pst;
}

//往pushST中插入数据
void myQueuePush(MyQueue* obj, int x)
{
    //调用栈的插入方法
    SrackPush(&obj->pushST,x);//往pushST中插入数据
}

//删除数据
int myQueuePop(MyQueue* obj)
{
    //1.检查popST是否为空
       //1)不为空直接 出
       //2)为空，pushST导入到popST,在出数据
    if(StackEmpty(&obj->popST))//如果为空的话，我们就进项导数据操作
    {
        //导数据
        while(!StackEmpty(&obj->pushST))//只要不为空，我们就将这个栈内的数据导出
        {
            //循环取栈顶数据
            //StackTop(&obj->pushST)将这个栈内的栈顶数据取出
            SrackPush(&obj->popST,StackTop(&obj->pushST));
            //将pushST这个栈的栈顶数据导入到popST中

            //取完数据，插入完数据之后我们再将进行pop操作，换下个数
            SrackPop(&obj->pushST);
            //下次我们取到的就是新的栈顶元素
        }
    }
    //取栈顶，删除栈顶元素并返回栈顶数据
    int top=StackTop(&obj->popST);//将这个栈的栈顶元素保存出来
    SrackPop(&obj->popST);//将栈顶元素删除，下次就是新的栈顶元素
    return top;
}
//取队头元素
int myQueuePeek(MyQueue* obj)
{
    //1.检查popST是否为空
       //1)不为空直接 出
       //2)为空，pushST导入到popST,在出数据
    if(StackEmpty(&obj->popST))//如果为空的话，我们就进项导数据操作
    {
        //导数据
        while(!StackEmpty(&obj->pushST))//只要不为空，我们就将这个栈内的数据导出
        {
            //循环取栈顶数据
            //StackTop(&obj->pushST)将这个栈内的栈顶数据取出
            SrackPush(&obj->popST,StackTop(&obj->pushST));
            //将pushST这个栈的栈顶数据导入到popST中

            //取完数据，插入完数据之后我们再将进行pop操作，换下个数
            SrackPop(&obj->pushST);
            //下次我们取到的就是新的栈顶元素
        }
    }
    //取栈顶，删除栈顶元素并返回栈顶数据
    return StackTop(&obj->popST);//我们直接将这个栈顶数据返回


}

//判断我们的队列是否为空，就是判断这个队列里面的两个栈是否为空
bool myQueueEmpty(MyQueue* obj)
{
    //如果这两个栈都不为空，那么这个队列就不为空
    return StackEmpty(&obj->pushST)  &&StackEmpty(&obj->popST);
}

//销毁
void myQueueFree(MyQueue* obj)
{
    STDestory(&obj->pushST);
    STDestory(&obj->popST);
    free(obj);
    obj=NULL;
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);

 * int param_2 = myQueuePop(obj);

 * int param_3 = myQueuePeek(obj);

 * bool param_4 = myQueueEmpty(obj);

 * myQueueFree(obj);
*/

题目四：设计循环队列

//推荐循环队列底层队列为数组

/*
插入数据：循环队列满了，就不能插入数据


*/

/*
一开始的front指向的是数组的头元素
rear也是指向数组的头元素
每次插入一个元素，rear就进行++操作
我们在下面申请了k+1个整型的空间，最后一个空间仅仅只是占位置的，不是存储数据的，实际存储数据的只有k个
假设这里是5个空间
0 1 2 3 4  这是对应的下标
一开始的front和rear都指向的是0，每次增加一个元素，rear++
等rear指向4的时候这个数组就存满了

因为是循环，最后rear++会回到front的位置
那么我们可以通过(rear+1)%(k+1)==front来判断队列是否满了
rear==front可以判断队列是否为空
*/
//定义循环队列的结构
typedef struct
{
    int *arr;
    int rear;
    int front;
    int capacity;//保存数组的空间的大小k
} MyCircularQueue;

//循环队列的初始化
MyCircularQueue* myCircularQueueCreate(int k)//我们根据这个K进行动态的申请内存,这里的返回值是指向循环队列的指针
{
    MyCircularQueue*pst=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));//先开辟队列的空间
    //因为队列的底层结构是数组，那么我们再为数组开辟空间
    pst->arr=(int*)malloc(sizeof(int)*(k+1));//我们给数组申请K+1个整型大小的空间

    pst->front=pst->rear=0;
    pst->capacity=k;//循环队列的容量大小是k
    return pst;
}
//判断队列是否满了
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    return (obj->rear+1)%(obj->capacity+1)==obj->front;//就说明满了
    //capacity+1是数组的容量大小，多出的1是用来占位置的
}

//向循环队列里面插入数据，如果成功插入就返回真
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
    //队列如果满了的话就不能进行插入数据的操作了
    if(myCircularQueueIsFull(obj))//如果满了的话,就不能插入数据了
    {
        return false;
    }

    //走到这里说明队列还没有满，我们就进行插数据操作
    obj->arr[obj->rear++]=value;//插入完数据之后rear要进行++的操作
    //为了保证循环的效果
    /*
    假设我们的rear此时在占位置的那个位置，就是多出来的1的那个位置
    为了保证循环，我们要让rear回到数组的第一个位置 */
    obj->rear%=obj->capacity+1;//obj->rear=obj->rear % (obj->capacity+1)//我们这里进行求余的操作，将结果给rear

    //插入完成我们就返回true
    return true;
}
//判断队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    return obj->rear==obj->front;
}

//从循环队列中删除一个元素，成功删除就返回true
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
    //既然要删除数据，那么队列就不能为空
    if(myCircularQueueIsEmpty(obj))//说明这个数组为空，我们就不进行删除数据的操作了
    {
        return false;
    }

    //走到这里说明队列不为空，那么我们就进行删除操作
    obj->front++;
    obj->front%=obj->capacity+1;//取余
    //原先front位置的数据还在，但是我们现在front已经换位置了，那么原先位置的数据就能就行插入数据了
    return true;
}
//取对首元素，返回对应值
int myCircularQueueFront(MyCircularQueue* obj)
{
    //队列为空就没啥数据能取
    //判断队列是否为空
    if(myCircularQueueIsEmpty(obj))//队列为空的话我们直接返回-1
    {
        return -1;
    }
    return obj->arr[obj->front];
}
//取对尾元素，返回对应值
int myCircularQueueRear(MyCircularQueue* obj)
{
    //队列为空就没啥数据能取
    //判断队列是否为空
    if(myCircularQueueIsEmpty(obj))//队列为空的话我们直接返回-1
    {
        return -1;
    }
    //return obj->arr[obj->rear-1];//rear指向的是最后一个数据的下一个位置
    //假如我们的rear指向的是0下标的数，那么rear-1不就是-1吗？这么写代码就是错的，，存在越界情况
    int prev=obj->rear-1;//定义一个指针指向rear前一个数据
    if(obj->rear==0)
    {
        prev=obj->capacity;//下标为4，那么就是这个数组的第5个位置，就是最后一个位置
    }
    return obj->arr[prev];
    //队尾元素就是rear经历过++操作之前的位置的元素
}

//循环队列的销毁
void myCircularQueueFree(MyCircularQueue* obj)
{
    free(obj->arr);
    free(obj);
    obj=NULL;
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);

 * bool param_2 = myCircularQueueDeQueue(obj);

 * int param_3 = myCircularQueueFront(obj);

 * int param_4 = myCircularQueueRear(obj);

 * bool param_5 = myCircularQueueIsEmpty(obj);

 * bool param_6 = myCircularQueueIsFull(obj);

 * myCircularQueueFree(obj);
*/

凯子坚持 c

关注

29
点赞
踩
23

收藏

觉得还不错? 一键收藏
21
评论
手撕数据结构---栈和队列的概念以及实现

栈：⼀种特殊的线性表，其只允许在固定的⼀端进⾏插⼊和删除元素操作。进⾏数据插⼊和删除操作的⼀端称为栈顶，另⼀端称为栈底。概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列中的每一个数据是通过一个节点保存的，节点和节点之间是通过指针链接的，压栈：栈的插⼊操作叫做进栈/压栈/⼊栈，⼊数据在栈顶。队列的底层是链表，链表是由一个一个的节点组成。⼊队列：进⾏插⼊操作的⼀端称为队尾。出队列：进⾏删除操作的⼀端称为队头。
复制链接

扫一扫

专栏目录