链表数组OJ题汇总

前言： 

在计算机科学中，数组和链表是两种常见的数据结构，用于存储和组织数据。它们分别具有不同的特点和适用场景。

本博客将深入讨论数组和链表在OJ题目中的应用。我们将从基本概念开始，介绍数组和链表的定义和特点，并分析它们在不同场景下的优势和劣势。

接下来，我们将探讨数组在OJ题目中的常见应用。我们将介绍如何原地移除数组中所有的val元素，如何删除排序数组中的重复项，以及如何合并两个有序数组。

随后，我们将探讨链表在OJ题目中的常见应用。我们将介绍如何删除链表中值为val的所有节点，如何翻转单链表，如何返回链表的中间结点和倒数第k个结点，以及如何合并两个有序链表等。

此外，我们还将介绍一些更复杂的链表问题，如链表的分割、回文链表、相交链表、带环链表等。我们将详细讲解每个问题的解题思路和实现方法。

最后，我们将讨论带有随机指针的链表，介绍如何复制这种特殊的链表结构，并解决相关问题。

通过对这些数组和链表的OJ题目的探讨，我们将加深对数组和链表的理解，并学会在实际问题中灵活运用它们。希望本博客能帮助读者更好地掌握这两种数据结构，并提升解题能力。让我们开始吧！

个人主页：Oldinjuly的个人主页

收录专栏：数据结构

欢迎各位点赞👍收藏⭐关注❤️

​

目录

🌹一、数组

💐1.原地移除数组中所有的val元

💐2.删除排序数组中的重复项

💐3.合并两个有序数组

🌹二、链表

💐1.删除链表中值为val的所有节点

💐2.翻转单链表

💐3.返回中间结点

💐4.返回倒数第k个结点

💐6.链表分割

💐 7.回文链表

💐8.相交链表

💐9.带环链表Ⅰ

💐10.带环链表Ⅱ

💐11.复制带随机指针的链表

🌹一、数组

💐1.原地移除数组中所有的val元素

​​

 方法一：暴力删除,挪动数据覆盖: 时间复杂度O(N^2), 空间复杂度O(1)

方法二：开辟新空间tmp，设置两个“指针”dst和src，nums[src]不等于val的直接插入到tmp[dst]中，等于val的直接跳过，然后tmp拷贝到nums中。

int removeElement(int* nums, int numsSize, int val)
{
    int* tmp = (int*)malloc(sizeof(int)*numsSize);
    int dst=0,src=0;
    while(src<numsSize)
    {
        if(nums[src]!=val)
        {
            tmp[dst++]=nums[src++];
        }
        else
        {
            src++;
        }
    }
    memcpy(nums,tmp,sizeof(int)*dst);
    return dst;
}

方法三：双指针在原数组上直接覆盖

nums[src]不等于val，直接覆盖尾插到dst位置，++dst，++src。

nums[src]等于val，直接++src，相当于删除。

​ 

int removeElement(int* nums, int numsSize, int val)
{
    int dst=0,src=0;
    while(src < numsSize)
    {
        if(nums[src] != val)
        {
            nums[dst++] = nums[src++];
        }
        else
        {
            src++;
        }
    }
    return dst;
}

💐2.删除排序数组中的重复项

​

​

双指针dst和src：

dst和src如果相等，src++。

dst和src如果不相等，dst先++，然后src覆盖到dst上，src再++。

​

int removeDuplicates(int* nums, int numsSize)
{
    int dst=0, src=0;
    while(src<numsSize)
    {
        if(nums[dst]==nums[src])
        {
            src++;
        }
        else
        {
            nums[++dst]=nums[src++];
        }
    }
    return ++dst;
}

💐3.合并两个有序数组

​

​

1.从前往后归并，需要开新空间

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
    int* tmp = (int*)malloc(sizeof(int)*(m+n));
    int begin1=0, begin2=0, pos=0;

    while(begin1 < m && begin2 < n)
    {
        if(nums1[begin1] < nums2[begin2])
        {
            tmp[pos++]=nums1[begin1++];
        }
        else
        {
            tmp[pos++]=nums2[begin2++];
        }
    }

    while(begin1 < m)
    {
        tmp[pos++]=nums1[begin1++];
    }

    while(begin2 < n)
    {
        tmp[pos++]=nums2[begin2++];
    }

    memcpy(nums1,tmp,sizeof(int)*(m+n));
    free(tmp);
}

2.从后往前归并，不需要开新空间

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{
    int end1=m-1,end2=n-1,end=m+n-1;
    while(end1>=0&&end2>=0)
    {
        if(nums1[end1]>nums2[end2])
        {
            nums1[end--]=nums1[end1--];
        }
        else
        {
            nums1[end--]=nums2[end2--];
        }
    }

    while(end2>=0)
    {
        nums1[end--]=nums2[end2--];
    }
}

🌹二、链表

💐1.删除链表中值为val的所有节点

​

解法一：在原链表上进行操作

struct ListNode* removeElements(struct ListNode* head, int val)
{
    struct ListNode* cur = head;
    struct ListNode* prev = NULL;
    while(cur)
    {
        if(cur->val == val)
        {
            if(cur == head)
            {
                head = cur->next;
                free(cur);
                cur = head;
            }
            else
            {
                prev->next = cur->next;
                free(cur);
                cur = prev->next;
            }

        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    }
    return head;
}

注意：头删不需要prev节点，是要单独讨论的。

解法二：创建一个新链表

struct ListNode* removeElements(struct ListNode* head, int val)
{
    struct ListNode* newhead = NULL, *tail = NULL, *cur = head;
    while(cur)
    {
        if(cur->val == val)
        {
            struct ListNode* next = cur->next;
            free(cur);
            cur = next; 
        }
        else 
        {
            if(newhead == NULL)
            {
                newhead = cur;
                tail = cur;
            }
            else
            {
                tail->next = cur;
                tail = tail->next;
            }

            cur = cur->next;
        }
    }

    if(tail)
    {
        tail->next = NULL;
    }

    return newhead;
}

注意：

  • 逻辑上的一个新链表，但是内存没有额外开辟空间。
  • 避免每次重复找尾结点，设置一个tail指针变量来记录。
  • 最后要给tail的next置空。

💐2.翻转单链表

​

​

解法一：三指针链接法

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode *n1, *n2, *n3;
    n1 = NULL;
    n2 = head;
    if(head)
    n3 = head->next;

    while(n2)
    {
        n2->next = n1;

        n1 = n2;
        n2 = n3;

        if(n3)
        n3 = n3->next;
    } 
    return n1;
}

问题：为什么设置三个指针变量进行迭代？

如果只设置两个指针变量进行迭代，n1赋值n2的next域之后，n2就无法迭代带原本的next域，而三个指针变量可以解决这个问题。

注意：n3进行迭代之前要判断n3是否为NULL。

解法二：头插法

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* newhead = NULL;
    struct ListNode* cur = head;

    while(cur)
    {
        struct ListNode* next = cur->next;
        cur->next = newhead;
        newhead = cur;

        cur = next;
    }

    return newhead;
}

💐3.返回中间结点

​

双指针（快慢指针）：fast指针走两步，slow指针走一步

奇数个链表节点：fast == NULL，slow对应中间结点

偶数个链表结点：fast->next == NULL，slow对应中间节点

struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode *slow = head, *fast = head;

    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
  
    return slow;
}

💐4.返回倒数第k个结点

​

双指针：

fast指针先走k步，然后两个指针一起走，fast走到NULL，slow走到目标节点。

fast指针先走k-1步，然后两个指针一起走，fast走到尾结点，slow走到目标节点。

struct ListNode* getKthFromEnd(struct ListNode* head, int k)
{
    struct ListNode *fast = head, *slow = head;
    int i = 0;

    for(i=0;i<k;i++) 
    {
        //链表没有k步长，那么倒数就是空
        if(!fast)
        	return NULL;

        fast = fast->next;
    }

    /*while(k--)//k--走k步，--k走k-1步
    {
	if(!fast)
        	return NULL;

        fast = fast->next;
    }*/

    while(fast)
    {
        fast = fast->next;
        slow = slow->next;
    }

    return slow;
}

💐5.合并两个有序链表

​

​

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    struct ListNode *head = NULL, *tail = NULL;

    if(!list1)
    return list2;
    if(!list2)
    return list1;

    while(list1 && list2)
    {
        if(list1->val < list2->val)
        {
            if(head == NULL)
            {
                head = list1;
                tail = list1;
            }
            else
            {
                tail->next = list1;
                tail= tail->next;
            }
            list1 = list1->next;
        }
        else
        {
            if(head == NULL)
            {
                head = list2;
                tail = list2;
            }
            else
            {
                tail->next = list2;
                tail= tail->next;
            }
            list2 = list2->next;
        }
    }

    if(list1)
    {
        tail->next = list1;
    }
    if(list2)
    {
        tail->next = list2;  
    }

    return head;
}

注意：

  • while循环的条件是list1&&list2，循环里面是继续条件，但是我们心中想的是循环终止条件，也就是有一个链表结束循环也就结束。
  • 当循环结束后，只需要把 没有遍历到空的链表尾接到tail后面即可。

这题合并有序链表和合并有序数组都使用了一个关键思想：归并，这也是排序算法的一个重要思想。

代码优化：

这里的归并使用了尾插，不带头结点单链表的尾插有一个缺点，就是第一次插入不需要找tail，直接赋值给head即可，需要单独讨论；为了使代码简洁，此时就需要另一种链表：带头结点（哨兵位）的单链表。

头结点什么数据也不存储，那么这个头结点有什么意义呢？

  • 尾插尾删不需要单独讨论，形成统一化。
  • 不需要传二级指针了，改的是头结点的next，修改结构体，直接传结构体指针即可。
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    if(!list1)
        return list2;
    if(!list2)
        return list1;


    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* tail = head;

    while(list1 && list2)
    {
        if(list1->val < list2->val)
        {
            tail->next = list1;
            tail = tail->next;

            list1 = list1->next;
        }
        else
        {
            tail->next = list2;
            tail = tail->next;

            list2 = list2->next;
        }
    }

    if(list1)
        tail->next = list1;

    if(list2)
        tail->next = list2;

    struct ListNode* next = head->next;
    free(head);
    head = next;

    return head;
}

💐6.链表分割

​

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) 
    {
        ListNode *lHead, *lTail, *gHead, *gTail;
        lHead = lTail = (ListNode*)malloc(sizeof(ListNode));
        gHead = gTail = (ListNode*)malloc(sizeof(ListNode));
        ListNode* cur = pHead;

        while(cur)
        {
            if(cur->val < x)
            {
                lTail->next = cur;
                lTail = lTail->next;
            }
            else
            {
                gTail->next = cur;
                gTail = gTail->next;
            }

            cur = cur->next;
        }

        lTail->next = gHead->next;
        //不置空，可能会出现环
        gTail->next = NULL;

        ListNode* next = lHead->next;
        free(lHead);
        free(gHead); 
        return next; 
    }
};

注意：

  • 该题开辟了两个链表头结点：lessHead，greaterHead，lessHead存放比x小的节点，greaterHead存放大于等于x的节点。
  • 这题最好使用带头结点的单链表，原因：如果不带头结点，lessHead为空或者greaterHead为NULL的话，此时链接两个链表lTail->next = gHead->next这句代码就会出错。
  • greaterTail的next的要置空，否则会出现环。

​

💐 7.回文链表

​

思路：

对于链表1->2->3->2->1->NULL；想判断是否回文，可以先将链表后半部分3->2->1->NULL进行逆置变成1->2->3->NULL;然后前半部分和后半部分进行比较，全部相等就是回文链表。 

​

这里要复用之前的两个题目的函数：返回中间节点和翻转单链表。

struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode *slow = head, *fast = head;

    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
  
    return slow;
}

struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* newhead = NULL;
    struct ListNode* cur = head;

    while(cur)
    {
        struct ListNode* next = cur->next;
        cur->next = newhead;
        newhead = cur;

        cur = next;
    }

    return newhead;
}

bool isPalindrome(struct ListNode* head)
{
    struct ListNode* headA = head;
    struct ListNode* headB = middleNode(head);

    struct ListNode* curA = headA;
    struct ListNode* curB = reverseList(headB);;


    while(curA && curB)
    {
        if(curA->val != curB->val)
            return false;

        curA = curA->next;
        curB = curB->next;
    }

    return true;
}

💐8.相交链表

​

​

补充：相交链表

上一道题目回文链表中，后半部分逆置过后的链表其实就是相交链表。

相交链表是这样的：

 ​

 而不是这样：

​

解法一：暴力遍历，headA的每一个节点都和headB的每一个节点比较（比较的是节点指针，不能比较val），时间复杂度O（N^2）。

解法二：

先遍历两个链表得到两个链表的长度，先判断尾结点是否相等，如果不相等一定不是相交链表；

再算出长度差，让长的先走长度差步，然后一起走，第一个相等的就是公共结点。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode *curA = headA, *curB = headB;
    int lenA = 1, lenB = 1;

    while(curA->next)//这里是为了找到尾结点，所以len初始化成1
    {
        curA = curA->next;
        lenA++;
    }  

    while(curB->next)
    {
        curB = curB->next;
        lenB++;
    }

    //不相交
    if(curA != curB)
        return NULL;  

    int dis = abs(lenA - lenB);
    struct ListNode *longList = headA, *shortList = headB;
    if(lenA < lenB)
    {
        longList = headB;
        shortList = headA;
    }

    while(dis--)
    {
        longList = longList->next;
    }

    while(longList != shortList)
    {
        longList = longList->next;
        shortList = shortList->next;
    }

    return longList;
}

💐9.带环链表Ⅰ

​

​

 这题也可以用快慢指针来解决：

fast指针：一次走两步

slow指针：一次走两步

在两个指针都进环后，他们在环中的某个位置一定能相遇！为什么呢？这要用相对运动的思想来分析一下了：

  •  我们可以把带环链表进行抽象化，便于分析：

​ 

 

  • 首先fast指针一定比slow指针先入环：

​

 

  • slow指针入环后，fast指针开始追赶slow指针，只是典型的追击问题，假设slow入环后两者距离为N。

​

 

  • slow走一步，fast走两步，每追击一次，两者的距离缩短1。两者的距离变化：N->N-1->N-2->...->1->0
  • 综上，两者的距离最终为0，会相遇。
bool hasCycle(struct ListNode *head) 
{
    struct ListNode *fast = head, *slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;

        if(fast == slow)
            return true;  
    }

    return false;   
}

思考：如果fast一次走三步、四步？他们会在环中相遇吗？

答案是不一定！

分析：

​

所以：初始距离M和C-1均为奇数的话，他们永不相遇！fast一次走四步也是一样的道理，综上fast最好的步数就是两步。 

💐10.带环链表Ⅱ

​

​ 

​

 解法一：需要一些数学知识来分析：​

struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode *slow = head, *fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;

        if(fast == slow)
        {
            struct ListNode* meet = slow;
            struct ListNode* cur = head;

            while(cur != meet)
            {
                cur = cur->next;
                meet = meet->next;
            }

            return cur;
        }
    }

    return NULL;
}

解法二：相交链表法 

​

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode *curA = headA, *curB = headB;
    int lenA = 1, lenB = 1;

    while(curA->next)//这里是为了找到尾结点，所以len初始化成1
    {
        curA = curA->next;
        lenA++;
    }  

    while(curB->next)
    {
        curB = curB->next;
        lenB++;
    }

    //不相交
    if(curA != curB)
        return NULL;  

    int dis = abs(lenA - lenB);
    struct ListNode *longList = headA, *shortList = headB;
    if(lenA < lenB)
    {
        longList = headB;
        shortList = headA;
    }

    while(dis--)
    {
        longList = longList->next;
    }

    while(longList != shortList)
    {
        longList = longList->next;
        shortList = shortList->next;
    }

    return longList;
}

struct ListNode *detectCycle(struct ListNode *head) 
{
    struct ListNode *fast = head, *slow = head;

    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;

        if(fast == slow)
        {
            struct ListNode* meet = slow;
            struct ListNode* newhead = meet->next;
            meet->next = NULL;

            return getIntersectionNode(head,newhead);
        }
    }   

    return NULL;
}

💐11.复制带随机指针的链表

​

​​

分析：所谓深拷贝，就是malloc出新的节点，然后把原始结点的数据赋值到新结点中。并且新链表随机指针的链接关系要和原链表的链接关系相同。

方法一：首先拷贝原链表的结点得到一个新链表，然后记录每个结点和他random域结点的相对位置，或者给每个节点设置一个索引值。通过相对位置来调整新链表的random域的链接关系。（注意：一定不能通过原链表的random域的值来进行链接，否则拷贝链表中的指针会指向原链表中。）

时间复杂度：O（N^2）

方法二：让拷贝结点插入到原节点的后面，然后置每个拷贝节点的random域，最后把拷贝结点给解下来并恢复原链表。

​

struct Node* copyRandomList(struct Node* head) 
{
    //拷贝结点插入到原节点的后面
    struct Node* cur = head;
    while(cur)
    {
        struct Node* next = cur->next;
        struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;

        cur->next = copy;
        copy->next = next;

        cur = next;
    } 

    //置一下拷贝节点的random域
    cur = head;
    while(cur)
    {
        struct Node* copy = cur->next;

        if(cur->random == NULL)
        {
            copy->random = NULL;
        }
        else
        {
            copy->random = cur->random->next;
        }

        cur = copy->next;
    }

    //把拷贝结点尾插下来，并且恢复原结点
    cur = head;
    struct Node *copyhead = NULL, *copytail = NULL;
    while(cur)
    {
        struct Node *copy = cur->next, *next = copy->next;

        //copy节点尾插到新链表
        if(copyhead == NULL)
        {
            copyhead = copytail =copy;
        }
        else
        {
            copytail->next = copy;
            copytail = copytail->next;
        }

        //恢复原链表
        cur->next = next;

        cur = next;
    }

    return copyhead;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/69464.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Visual ChatGPT：Microsoft ChatGPT 和 VFM 相结合

Visual ChatGPT：Microsoft ChatGPT 和 VFM 相结合

推荐&#xff1a;使用 NSDT场景编辑器助你快速搭建可二次编辑的3D应用场景 什么是Visual ChatGPT&#xff1f; Visual ChatGPT 是一个包含 Visual Foundation 模型 &#xff08;VFM&#xff09; 的系统&#xff0c;可帮助 ChatGPT 更好地理解、生成和编辑视觉信息。VFM 能够指…
阅读更多...
《漫画算法：小灰的算法之旅》——赠书活动

《漫画算法：小灰的算法之旅》——赠书活动

我想应该有很多人对我今天推荐的书籍不陌生&#xff0c;《漫画算法&#xff1a;小灰的算法之旅》已经是圈内人熟知的“红人”了&#xff0c;但也存在不断有新人入坑&#xff0c;这里就好好介绍一下这本包上“糖衣”的算法“炮弹”吧&#xff0c;整个过程如同本书形象“Q弾可爱&…
阅读更多...
【css】textarea-通过resize:none 禁止拖动设置大小

【css】textarea-通过resize:none 禁止拖动设置大小

使用 resize 属性可防止调整 textareas 的大小&#xff08;禁用右下角的“抓取器”&#xff09;&#xff1a; 没有设置resize:none 代码&#xff1a; <!DOCTYPE html> <html> <head> <style> textarea {width: 100%;height: 150px;padding: 12px 20p…
阅读更多...
Android开源 Skeleton 骨架屏

Android开源 Skeleton 骨架屏

目录 一、简介 二、效果图 三、引用 Skeleton 添加jitpack 仓库 添加依赖: 四、使用 Skeleton 1、VIew 骨架屏使用 ViewSkeletonScreen 2、列表类View 骨架屏 RecyclerViewSkeletonScreen、GridViewSkeletonScreen、 ListViewSkeletonScreen 一、简介 骨架屏的作用是…
阅读更多...
【C++】开源：ceres和g2o非线性优化库配置使用

【C++】开源：ceres和g2o非线性优化库配置使用

&#x1f60f;★,:.☆(&#xffe3;▽&#xffe3;)/$:.★ &#x1f60f; 这篇文章主要介绍ceres和g2o非线性优化库配置使用。 无专精则不能成&#xff0c;无涉猎则不能通。——梁启超 欢迎来到我的博客&#xff0c;一起学习&#xff0c;共同进步。 喜欢的朋友可以关注一下&…
阅读更多...
极客教程 scrapy和selenium

极客教程 scrapy和selenium

selenium 极客教程 使用python 调用scrapy的 爬虫Spider并且相互之间可以正常传参实现全局 常规情况创建&#xff0c;使用命令 scrapy genspider baidu "baidu.com"Python中Scrapy框架详解 浏览器调试模式下&#xff08;F12 或 右键检查&#xff09;Command sh…
阅读更多...
linux 下 网卡命名改名

linux 下 网卡命名改名

Linux 操作系统的网卡设备的传统命名方式是 eth0、eth1、eth2等&#xff0c;而 CentOS7 提供了不同的命名规则&#xff0c;默认是网卡命名会根据网卡的硬件信息&#xff0c;插槽位置等有关&#xff1b;来分配。这样做的优点是命名全自动的、可预知的&#xff0c;缺点是比 eth0、…
阅读更多...
【数学】CF1514 C

【数学】CF1514 C

Problem - 1514C - Codeforces 题意&#xff1a; 思路&#xff1a; Code&#xff1a; #include <bits/stdc.h>using i64 long long;constexpr int N 2e5 10; constexpr int M 2e5 10; constexpr int mod 998244353;void solve() {int n;std::cin >> n;std:…
阅读更多...
基于SpringBoot+Vue的地方美食分享网站设计与实现（源码+LW+部署文档等）

基于SpringBoot+Vue的地方美食分享网站设计与实现（源码+LW+部署文档等）

博主介绍&#xff1a; 大家好&#xff0c;我是一名在Java圈混迹十余年的程序员&#xff0c;精通Java编程语言&#xff0c;同时也熟练掌握微信小程序、Python和Android等技术&#xff0c;能够为大家提供全方位的技术支持和交流。 我擅长在JavaWeb、SSH、SSM、SpringBoot等框架…
阅读更多...
Tailwind CSS：简洁高效的工具，提升前端开发体验

Tailwind CSS：简洁高效的工具，提升前端开发体验

112. Tailwind CSS&#xff1a;简洁高效的工具&#xff0c;提升前端开发体验 1. 什么是Tailwind CSS&#xff1f; Tailwind CSS是由Adam Wathan、Jonathan Reinink、David Hemphill和Steve Schoger等人共同创建的一种现代CSS框架。与传统的CSS框架不同&#xff0c;Tailwind CS…
阅读更多...
OpenEuler 上安装redis服务

OpenEuler 上安装redis服务

访问redis的下载地址 Index of /releases/地址&#xff1a;Index of /releases/ 选择对应的版本。我选择5.0的版本。 下载对应的版本redis wget https://download.redis.io/releases/redis-5.0.8.tar.gz 解压 redis tar -zxvf redis-5.0.9.tar.gz 进入redis目录 cd redis-5…
阅读更多...
[git] git基础知识

[git] git基础知识

git是一个免费的、开源的分布式版本控制系统&#xff0c;可以快速高效地处理从小型到大型的各种项目 git易于学习&#xff0c;性能极快 什么是版本控制&#xff1f; 版本控制是一种记录文件内容变化&#xff0c;以便将来查阅特定版本修订情况&#xff0c;可以记录文件修改历史…
阅读更多...
React 全栈体系（一）

React 全栈体系（一）

第一章 React入门 一、React简介 1. 是什么&#xff1f; 是一个将数据渲染为HTML视图的开源JavaScript库。 2. 谁开发的&#xff1f; 由Facebook开源 3. 为什么要学&#xff1f; 原生JavaScript操作DOM繁琐&#xff0c;效率低&#xff08;DOM-API 操作 UI&#xff09; 使…
阅读更多...
竞赛项目 深度学习图像风格迁移 - opencv python

竞赛项目 深度学习图像风格迁移 - opencv python

文章目录 0 前言1 VGG网络2 风格迁移3 内容损失4 风格损失5 主代码实现6 迁移模型实现7 效果展示8 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习图像风格迁移 - opencv python 该项目较为新颖&#xff0c;适合作为竞赛课题…
阅读更多...
消息中间件 Asio (C++)

消息中间件 Asio (C++)

折腾了一上午&#xff0c;看到这个结果的时候泪目了兄弟闷&#xff0c;讲真。我的asio客户端成功收到服务端发来的消息了。虽然这确实是极其智障又简单的入门哈哈 下载独立版本 asio网络通信库新建cmake工程&#xff0c;CMakeLists.txt加载asioasio最简单的服务端和客户端代码…
阅读更多...
echarts 横向柱状图

echarts 横向柱状图

<template><div ref"chart" style"height: 100%"></div> </template><script> import * as echarts from "echarts"; var cate ["质量通病1", "质量通病2", "质量通病3", "质…
阅读更多...
【C++】static_cast基本用法（详细讲解）

【C++】static_cast基本用法（详细讲解）

&#x1f449;博__主&#x1f448;&#xff1a;米码收割机 &#x1f449;技__能&#x1f448;&#xff1a;C/Python语言 &#x1f449;公众号&#x1f448;&#xff1a;测试开发自动化【获取源码商业合作】 &#x1f449;荣__誉&#x1f448;&#xff1a;阿里云博客专家博主、5…
阅读更多...
Kotlin～Mediator中介者模式

Kotlin～Mediator中介者模式

概念 创建一个中介来降低对象之间的耦合度&#xff0c;关系”多对多“变为“一对多”。 角色介绍 Mediator&#xff1a;抽象中介者&#xff0c;接口或者抽象类。ConcreteMediator&#xff1a;中介者具体实现&#xff0c;实现中介者接口&#xff0c;定义一个List管理Colleagu…
阅读更多...
【前端】CSS垂直居中的7种方法

【前端】CSS垂直居中的7种方法

文章目录 line-height绝对定位margin:autoflex绝对定位margin:负值定位transformvertical-align:middledisplay:table-cell思维导图 前文&#xff1a;【前端】CSS水平居中的6种方法_karshey的博客-CSDN博客 有很多相似的部分。 line-height 适用于单行的行内元素设置line-he…
阅读更多...
uniapp 左右滑动切换页面并切换tab

uniapp 左右滑动切换页面并切换tab

实现效果如图 要实现底部内部的左右滑动切换带动上方tab栏的切换&#xff0c;并且下方内容要实现纵向滚动 &#xff0c;所以需要swiper&#xff0c;swiper-item,scroll-view组合使用 tab栏部分 <view class"tabs"><view class"tab_item" v-for&…
阅读更多...
最新文章

Copyright @ 2022~2023