力扣练习23_5_20

最新推荐文章于 2024-07-19 19:25:43 发布
最新推荐文章于 2024-07-19 19:25:43 发布
阅读量33 收藏
点赞数
文章标签： leetcode 算法 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73771247/article/details/130786642
版权

力扣练习

有效的括号

在这里插入图片描述

主要是栈的实现，理解了就简单了，这次需要注意的是开辟空间用int,一开始用char时一直运行不出来

typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    STDataType top;
    STDataType capacity;
}ST;

void StackInit(ST* pst)
{
    assert(pst);
    pst->a=NULL;
    pst->top=0;
    pst->capacity=0;
}

void StackPush(ST* pst,STDataType x)
{
    assert(pst);
    if(pst->top==pst->capacity)
    {
        STDataType newcapacity=pst->capacity==0?4:pst->capacity*2;
        STDataType* newnode=(STDataType*)realloc(pst->a,sizeof(STDataType)*newcapacity);
        if(newnode==NULL)
        {
            printf("realloc fail");
            return;
        }
        pst->a=newnode;
        pst->capacity=newcapacity;
    }
    
    pst->a[pst->top]=x;
    pst->top++;
}

bool StackEmpty(ST* pst)
{
     assert(pst);
     return pst->top==0;
}

void StackPop(ST* pst)
{
    assert(pst);
    assert(!StackEmpty(pst));
    pst->top--;
}

void StackDestory(ST* pst)
{
    assert(pst);
    free(pst->a);
    pst->a=NULL;
    pst->top=pst->capacity=0;
}

STDataType StackTop(ST* pst)
{
    assert(pst);
    assert(!StackEmpty(pst));
    return pst->a[pst->top-1];
}

bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('
        ||*s=='{'
        ||*s=='[')
        {
            StackPush(&st,*s);
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestory(&st);
                return false;
            }
            STDataType top=StackTop(&st);
            StackPop(&st);
            if((*s==')'&&top!='(')||(*s==']'&&top!='[')||(*s=='}'&&top!='{'))
            {
                StackDestory(&st);
                return false;
            }
        }
        s++;
    }
    bool ret=StackEmpty(&st);
    StackDestory(&st);
    return ret;
}

用队列实现栈

在这里插入图片描述

用两个队列进行实现，非空队列的元素依次移到空队列，只剩最后一个元素时，打印该元素

typedef int QDataType;
typedef struct QListNode
{
    QDataType* next;
    QDataType data;
}QLNode;

typedef struct Queue
{
    QLNode* phead;
    QLNode* ptail;
    int size;
}Queue;

void QueueInit(Queue* pq)
{
    assert(pq);
    pq->phead=pq->ptail=NULL;
    pq->size=0;
}

void QueueDestory(Queue* pq)
{
    assert(pq);
    QLNode* cur=pq->phead;
    while(cur)
    {
        QLNode* next=cur->next;
        free(cur);
        cur=next;
    }
    pq->phead=pq->ptail=NULL;
    pq->size=0;
}

bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->size==0;
}

void QueuePush(Queue* pq,QDataType x)
{
    assert(pq);
    QLNode* newnode=(QLNode*)malloc(sizeof(QLNode));
    if(newnode==NULL)
    {
        printf("malloc fail");
        return;
    }
    newnode->next=NULL;
    newnode->data=x;

    if(pq->ptail==NULL)
    {
        assert(pq->phead==NULL);
        pq->phead=pq->ptail=newnode;
    }
    else
    {
        pq->ptail->next=newnode;
        pq->ptail=newnode;
    }
    pq->size++;
}

void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    if(pq->phead->next==NULL)
    {
        free(pq->phead);
        pq->phead=pq->ptail=NULL;
    }
    else
    {
        QLNode* next=pq->phead->next;
        free(pq->phead);
        pq->phead=next;
    }
    pq->size--;
}

QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->phead->data;
}

QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->ptail->data;
}

int QueueSize(Queue* pq)
{
    assert(pq);
    return pq->size;
}


typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    if(obj==NULL)
    {
        printf("malloc fail");
        return NULL;
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue* pqempty=&obj->q1;
    Queue* pqnonempty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        pqempty=&obj->q2;
        pqnonempty=&obj->q1;
    }

    while(QueueSize(pqnonempty)>1)
    {
        QueuePush(pqempty,QueueFront(pqnonempty));
        QueuePop(pqnonempty);
    }
    int top=QueueFront(pqnonempty);
    QueuePop(pqnonempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}

用栈实现队列

用两个栈实现，一个为pushst,一个为popst,将pushst数据依次放入popst中，依次输出，即为队列输出顺序

typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    STDataType top;
    STDataType capacity;
}Stack;

void StackInit(Stack* pt)
{
    assert(pt);
    pt->a=NULL;
    pt->top=pt->capacity=0;
}

void StackDestory(Stack* pt)
{
    assert(pt);
    free(pt->a);
    pt->a=NULL;
    pt->top=pt->capacity=0;
}

void StackPush(Stack* pt,STDataType x)
{
    assert(pt);
    if(pt->top==pt->capacity)
    {
        STDataType newcapacity=pt->capacity==0?4:pt->capacity*2;
        STDataType* ret=(STDataType*)realloc(pt->a,sizeof(STDataType)*newcapacity);
        if(ret==NULL)
        {
            printf("realloc fail");
            return;
        }
        pt->capacity=newcapacity;
        pt->a=ret;
    }
    pt->a[pt->top]=x;
    pt->top++;
}

bool StackEmpty(Stack* pt)
{
    assert(pt);
    return pt->top==0;
}

void StackPop(Stack* pt)
{
    assert(pt);
    assert(!StackEmpty(pt));
    pt->top--;
}

STDataType StackTop(Stack* pt)
{
    assert(pt);
    assert(!StackEmpty(pt));
    return pt->a[pt->top-1];
}



int StackSize(Stack* pt)
{
    assert(pt);
    return pt->top;
}



typedef struct {
    Stack pushst;
    Stack popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        printf("malloc fail");
        return NULL;
    }
    StackInit(&obj->pushst);
    StackInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushst,x);
}

int myQueuePop(MyQueue* obj) {
    int temp=myQueuePeek(obj);
    StackPop(&obj->popst);
    return temp;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    StackDestory(&obj->pushst);
    StackDestory(&obj->popst);
    free(obj);
}

设计循环队列

在这里插入图片描述

用数组实现队列，理解列表为空时：rear == front，满时：rear+1== front
当求队尾元素时，坐标为(rear-1+k+1)%(k+1)

typedef int QDataType;
typedef struct QNode
{
    struct QNode* next;
    QDataType data;
}QNode;

typedef struct Queue
{
    QNode* phead;
    QNode* ptail;
    int size;
}Queue;

void QueueInit(Queue* pq)
{
    assert(pq);
    pq->phead=NULL;
    pq->ptail=NULL;
    pq->size=0;
}

void QueueDestory(Queue* pq)
{
    assert(pq);
    QNode* cur=pq->phead;
    while(cur)
    {
        QNode* next=cur->next;
        free(cur);
        cur=next;
    }
    pq->phead=pq->ptail=NULL;
    pq->size=0;
}

bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->size==0;
}

void QueuePush(Queue* pq,QDataType x)
{
    assert(pq);
    QNode* newnode=(QNode*)malloc(sizeof(QNode));
    if(newnode==NULL)
    {
        printf("malloc fail");
        return;
    }
    newnode->next=NULL;
    newnode->data=x;

    if(pq->ptail==NULL)
    {
        assert(pq->phead==NULL);
        pq->ptail=pq->phead=newnode;
    }
    else
    {
        pq->ptail->next=newnode;
        pq->ptail=newnode;
    }
    pq->size++;
}

void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    if(pq->phead->next==NULL)
    {
        free(pq->phead);
        pq->phead=pq->ptail=NULL;
    }
    else
    {
        QNode* next=pq->phead->next;
        free(pq->phead);
        pq->phead=next;
    }
    pq->size--;
}

QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->phead->data;
}

QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->ptail->data;
}

int QueueSize(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->size;
}






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


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    if(obj==NULL)
    {
        printf("malloc fail\n");
        return NULL;
    }
    obj->front=obj->rear=0;
    obj->k=k;
    obj->a=(int*)malloc(sizeof(int)*(k+1));

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->k+1)==obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }

    obj->a[obj->rear]=value;
    obj->rear++;
    obj->rear%=(obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front%=(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
北以北城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
力扣练习23_5_19
m0_73771247的博客
05-21 32
日常练习
力扣练习4.25
qq_43814415的博客
04-25 1029
因为左子链表在奇数时会多一个中点，所以在同时合并两个子链表的前面位数的节点后，还需要加上左边剩余的节点。1.设置快慢指针，都从头节点开始，快指针一次移动两个单位，慢指针一个单位，当快指针移动到链表末尾时，慢指针位置就是中点。将整个链表拆成三部分，第一部分是头节点到left的前一个节点，第二部分是left到right的待反转区间，第三部分是right的下一个节点为头结点到尾部。链表的分割也是找中点，前面的题有过，与前面不同的是，这道题的中点是要包含在前面部分的，所以初始化fast不同；
python可以做力扣的题吗_力扣题目练习一
weixin_39969611的博客
12-06 82
10. 正则表达式匹配给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符'*' 匹配零个或多个前面的那一个元素所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。说明:s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。示例 1:输入:s = "aa"p = ...
力扣练习题
m0_48046714的博客
09-16 170
如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “”。给你一个字符串 s，「k 倍重复项删除操作」将会从 s 中选择 k 个相邻且相等的字母，并删除它们，使被删去的字符串的左侧和右侧连在一起。注意：对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。如果 s 中存在这样的子串，我们保证它是唯一的答案。在执行完所有删除操作后，返回最终得到的字符串。
C++ 哈希表-unordered_map、unordered_set力扣练习
迷途
12-19 387
从pair到unordered_map，理论+leetcode题目实战_unordered_map pair-CSDN博客【LeetCode】查找表问题：Map 常见典例_leetcode中map常用用法-CSDN博客leetcode c++（4）（哈希表unordered_map、散列表unordered_set、动态规划、substr()、有很多道双指针法）-CSDN博客
力扣练习4.23
qq_43814415的博客
04-23 972
如果重复，就将相邻的前一个元素另存为临时变量，并且循环判断相邻的后一个元素和其后的元素是否重复，重复则移动临时变量到下一个节点；将滑动窗口实现为双向队列，队列中存储索引，维护队列的第一个元素为窗口内最大值的索引，在每个窗口内取出第一个元素，在数组中访问即可得到每个滑动窗口内的最大值。3.状态转移方程：如果nums1[i-1] == nums2[j-1]，则dp[i][j]=dp[i-1][j-1]+1；临时变量退出循环后，其下一个元素是与前面的任意元素都不重复的，因此将指针指向临时变量的下一个元素。
多线程测试力扣练习题
qq_61353850的博客
08-23 254
多线程测试力扣题
力扣练习
admin_mds的博客
03-23 103
力扣练习 题目 题目连接 11 盛最多水的容器 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。 说明：你不能倾斜容器。 示例 1： 输入：[1,8,6,2,5,4,8,3,7] 输出：49 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。 在此情况下，容器能够容纳水（表示为蓝色部分）
SQL力扣练习（三）
阿七的博客
06-28 1167
下面也是力扣的同学写的，我简要说明一下思路，首先也是分为两部分，第一部分查出数据，第二部分负责筛选去重，rn是给按id排序加一下序号，作者应该是考虑到id不连续的情况。然后在去重的过程中，根据num和rn-id_rn排序，这里的第二个排序又可能不太好看出，因为上面的rn和id_rn都是根据id分组的，所以如果相减的话，他们也是同步的，而我们的num也不会重复，所以这样分组出来的数据是正确的。需要注意的是lag 取得是当前行之前的数据，lead 取的实当前行之后的数据。id 是这个表的主键。
前端力扣刷题_数据结构篇（树）
weixin_44915595的博客
11-23 963
## 二叉树的遍历方式 前序遍历、中序遍历、后序遍历都属于DFS（深度优先遍历），往往用递归实现。 递归就是思考这个函数的功能是什么！一定注意要有递归终止条件！（1，定义终止条件；2，实现功能；3，调用递归。23顺序不一定） **## 二叉树的前序遍历：** 此函数的功能就是给一个根节点，返回一个此节点的前序遍历数组。前序遍历的顺序是（中左右）：[root,（传入左子树根结点，返回）左子树的前序遍历，（传入右子树根结点，返回）右子树的前序遍历]...
Leet Code_力扣原题_leetcode官网_
10-01
标题“Leet Code_力扣原题_leetcode官网_”表明这个压缩包包含的是从力扣官网上收集的原题，可能是用户为了方便离线练习或分享而整理的。这些题目可能包括了力扣网站上的经典问题，涵盖排序、搜索、动态规划、图论、...
992. Subarrays with K Different Integers.cpp_Different_力扣992答案_源
09-30
力扣（LeetCode）是一个在线的编程练习平台，它提供了一系列算法和数据结构题目，帮助程序员提升技能并准备面试。 标签中的"Different"指的是题目要求计算具有不同整数的子数组，而"力扣992答案"再次强调了这是一个...
leetcode第四题-LeetCode_Exercise:力扣_练习
07-01
第四题力扣_练习 位掩码 结束了一些位操作和位掩码练习，难度由低到高总结了几道非常讲的位运算和位掩码题，难度由低到高 （简单的） （简单的） （强烈推荐） （中等的） （中）（强烈推荐） （中）（强烈推荐，...
z transfer_力扣；Z形变换_
09-30
在编程领域，力扣（LeetCode）是一个广受欢迎的在线平台，它提供了各种算法和编程题目，帮助开发者提升技能并准备面试。"Z形变换"是力扣中的一道题目，涉及字符串处理和二维数组操作。现在我们来深入探讨这个知识点...
pokemon:力扣练习
04-21
"pokemon:力扣练习"这个项目，从标题来看，似乎是以《精灵宝可梦》为主题，结合了编程学习的元素，可能是通过创建一个游戏或者模拟训练的方式来帮助用户提升JavaScript编程技能。"打怪升级"这一描述，暗示了项目可能...
力扣第233题“数字1的个数”
10年数据\经营分析经验，现任大厂数据分析负责人
07-15 700
本文详细解读了力扣第233题“数字1的个数”，通过使用逐位分析的方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
Leetcode - 周赛406
最新发布
m0_74859835的博客
07-19 319
Leetcode - 周赛406，主要知识点：dfs记忆化，贪心
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 178
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
leetcode简单题26 N.118 杨辉三角 rust描述
BECOMEviolet的博客
07-16 384
【代码】leetcode简单题26 N.118 杨辉三角 rust描述。
力扣python格式
09-23
力扣是一个在线的编程题库，在其中有各种算法和数据结构的题目，供程序员进行练习。力扣题库支持多种编程语言，包括Python。 力扣Python格式是指在力扣平台上使用Python语言解答问题时需要注意的一些细节和规范。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值