10道题熟练掌握并运用链表结构算法

news2024/11/17 15:57:09

目录

1.牛客BM3 链表中的节点每k个一组翻转

2.BM4 合并两个排序的链表

3.BM5 合并k个已排序的链表

4.BM6 判断链表中是否有环

5.BM7 链表中环的入口结点

6.BM8 链表中倒数最后k个结点

7.BM9 删除链表的倒数第n个节点

8.BM10 两个链表的第一个公共结点

9.BM11 链表相加(二)

10.BM12 单链表的排序

1.牛客BM3 链表中的节点每k个一组翻转

题目：将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表，如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样，你不能更改节点中的值，只能更改节点本身。

数据范围： \ 0 \le n \le 2000 0≤n≤2000 ， 1 \le k \le 20001≤k≤2000 ，链表中每个元素都满足 0 \le val \le 10000≤val≤1000
要求空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

例如：

给定的链表是 1\to2\to3\to4\to51→2→3→4→5

对于 k = 2k=2 , 你应该返回 2\to 1\to 4\to 3\to 52→1→4→3→5

对于 k = 3k=3 , 你应该返回 3\to2 \to1 \to 4\to 53→2→1→4→5

解：这道题用递归做效率是最高的，但不好理解。  

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param head ListNode类 
 * @param k int整型 
 * @return ListNode类
 */

struct ListNode*reverse (struct ListNode*phead,int k)
{
    struct ListNode*pre ,*cur ,*nxt;//创建3个新结点
    pre=NULL;cur=phead;nxt=phead->next;//pre为头结点
    while (k--) //在k区间内反转
    {
        cur->next=pre;
        pre=cur;
        cur=nxt;
        nxt=cur->next;
    }
    return  pre;//返回反转后的头结点
}

struct ListNode* reverseKGroup(struct ListNode* head, int k ) {
    // write code here
    struct ListNode* reverseHead=(struct ListNode*)malloc(sizeof(struct ListNode));
    reverseHead->next=head;
    struct ListNode *revHead,*revEnd;
    int count=0;
    revHead=reverseHead,revEnd=reverseHead->next;
    if(k==1)return reverseHead->next;
    while(revEnd!=NULL)
    {
        revEnd=revEnd->next;
        if(++count==k)//计数count等于k则开始反转
        {
            revHead->next=reverse(revHead->next, k);
            while(count--)
            {
                revHead=revHead->next;
            }
            revHead->next=revEnd;
            count=0;
        }
    }
    return reverseHead->next;
}

2.BM4 合并两个排序的链表

题目：输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

数据范围： 0 \le n \le 10000≤n≤1000，-1000 \le 节点值 \le 1000−1000≤节点值≤1000
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}

解：这道题和第一道比就比较简单了，直接笨想用两个指针分别指向两个链表然后比较大小，返回到新链中就可以了。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param pHead1 ListNode类 
 * @param pHead2 ListNode类 
 * @return ListNode类
 */
struct ListNode* Merge(struct ListNode* pHead1, struct ListNode* pHead2 ) {
    // write code here
    struct ListNode*p1=pHead1,*p2=pHead2,*res;
    struct ListNode*cur=(struct ListNode*)malloc(sizeof(struct ListNode));
    cur->val=-1;
    res=cur;
    while ((p1!=NULL&&p2!=NULL)) {
        if (p1->val<p2->val) {
            res->next=p1;
            res=res->next;
            p1=p1->next;
        }
        else {
        res->next=p2;
        res=res->next;
        p2=p2->next;
        }
    }
    if ((p1!=NULL)) {
        res->next=p1;
    }
    if ((p2!=NULL)) {
        res->next=p2;
    }
    return  cur->next;
}

 向上面那么做，理解起来非常容易，但也是入门的方法；

人写迭代，神写递归，接下来看看递归的程序怎么做

这道题给的函数功能就是合并两个排序的链表，那我们可以用这个函数本身来递归。

（恍然大悟，原来如此啊！迭代看着递归，表情惊恐：这就是神吗？竟恐怖如斯，自己递归自己。 ）呵呵呵呵，冷笑话~这道题其实递归和迭代时间复杂度是一样的，空间复杂度还不如迭代。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param pHead1 ListNode类 
 * @param pHead2 ListNode类 
 * @return ListNode类
 */
struct ListNode* Merge(struct ListNode* pHead1, struct ListNode* pHead2 ) {
    // write code here
    if (!pHead1) return pHead2;
    if (!pHead2) return pHead1;
    if (pHead1->val <= pHead2->val) {
         pHead1->next = Merge(pHead1->next, pHead2);
         return pHead1;
    }
    else {
         pHead2->next = Merge(pHead1, pHead2->next);
         return pHead2;
    }
}

3.BM5 合并k个已排序的链表

题目：合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

数据范围：节点总数 0 \le n \le 50000≤n≤5000，每个节点的val满足 |val| <= 1000∣val∣<=1000

要求：时间复杂度 O(nlogn)O(nlogn)

示例1

输入：

[{1,2,3},{4,5,6,7}]

复制返回值：

{1,2,3,4,5,6,7}

解：一样的做法，但是复杂了好多， free函数释放内存空间

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param lists ListNode类一维数组 
 * @param listsLen int lists数组长度
 * @return ListNode类
 */
struct ListNode* merger(struct ListNode** lists,int listLen,int left,int right){
    if(left == right) {
        return lists[left];
    }else{
        int mid = left + (right - left) / 2;
        struct ListNode* leftHead = merger(lists,listLen,left,mid);
        struct ListNode* rightHead = merger(lists,listLen,mid + 1,right);
        struct ListNode* newHead = (struct ListNode*)malloc(sizeof(struct ListNode));
        struct ListNode* pre = newHead, *p1 = leftHead, *p2 = rightHead;
        while(p1 && p2){
            if(p1->val < p2->val){
                pre->next = p1;
                pre = p1;
                p1 = p1->next;
            }else{
                pre->next = p2;
                pre = p2;
                p2 = p2->next;
            }
        }
        if(p1){
            pre->next = p1;
        }else if(p2){
            pre->next = p2;
        }
        pre = newHead->next;
        free(newHead);
        return pre;
    }
}
struct ListNode* mergeKLists(struct ListNode** lists, int listsLen ) {
    // write code here
    if(listsLen == 0) return NULL;
    return merger(lists,listsLen,0,listsLen - 1);
}

4.BM6 判断链表中是否有环

题目：判断给定的链表中是否有环。如果有环则返回true，否则返回false。

数据范围：链表长度 0 \le n \le 100000≤n≤10000，链表中任意节点的值满足 |val| <= 100000∣val∣<=100000

要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。

解：这道题超简单，用双指针一快一慢循环向前，相遇的时候就是有环。 

#include <stdbool.h>
/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param head ListNode类 
 * @return bool布尔型
 */
bool hasCycle(struct ListNode* head ) {
    // write code here
    struct ListNode *fast,*slow;
    fast=head;
    slow=head;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)
        {
            return true;
        }
    }
    return false;
}

5.BM7 链表中环的入口结点

题目：给一个长度为n链表，若其中包含环，请找出该链表的环的入口结点，否则，返回null。

数据范围： n\le10000n≤10000，1<=结点值<=100001<=结点值<=10000

要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

解：大风车呀~嘎吱，嘎吱的转~转就完了，兄弟们！

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param pHead ListNode类 
 * @return ListNode类
 */
struct ListNode* EntryNodeOfLoop(struct ListNode* pHead ) {
    // write code here
    struct ListNode *fast,*slow;
    fast=pHead;
    slow=pHead;
    while(fast!=NULL&&fast->next!=NULL)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow)break;
    }
    if(fast==NULL||fast->next==NULL)return NULL;
    fast=pHead;//重新指向头结点
    while(fast!=slow)
    {
        fast=fast->next;
        slow=slow->next;
    }
    return fast;
}

6.BM8 链表中倒数最后k个结点

题目：输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。

如果该链表长度小于k，请返回一个长度为 0 的链表。

数据范围：0 \leq n \leq 10^50≤n≤105，0 \leq a_i \leq 10^90≤ai​≤109，0 \leq k \leq 10^90≤k≤109

要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

进阶：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

示例1

输入：

{1,2,3,4,5},2

复制返回值：

{4,5}

复制说明：返回倒数第2个节点4，系统会打印后面所有的节点来比较。

解：还是用双指针。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param pHead ListNode类 
 * @param k int整型 
 * @return ListNode类
 */
struct ListNode* FindKthToTail(struct ListNode* pHead, int k ) {
    // write code here
    if(pHead==NULL)return NULL;
    struct ListNode*a,*b;
    a=b=pHead;
    int i=0;
    while(a!=NULL)
    {
        if(i<k)
        {
            i++;
        }
        else if(i==k)
        {
            b=b->next;
        }
        a=a->next;
    }
    if(i==k)
    {
        return b;
    }
    return NULL;
}

7.BM9 删除链表的倒数第n个节点

题目：给定一个链表，删除链表的倒数第 n 个节点并返回链表的头指针
例如，

给出的链表为: 1\to 2\to 3\to 4\to 51→2→3→4→5, n= 2n=2.
删除了链表的倒数第 nn 个节点之后,链表变为1\to 2\to 3\to 51→2→3→5.

数据范围： 链表长度 0\le n \le 10000≤n≤1000，链表中任意节点的值满足 0 \le val \le 1000≤val≤100

要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
备注：题目保证 nn 一定是有效的

 解：这道题本质上和上到题区别不大；

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param head ListNode类 
 * @param n int整型 
 * @return ListNode类
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n ) {
    // write code here
    if(head==NULL)return NULL;
    struct ListNode*fast,*slow;
    fast=slow=head;
    for(int i=0;i<n;i++)
    {
        fast=fast->next;
    }
    if(fast==NULL)return head->next;
    while(fast->next!=NULL)
    {
        fast=fast->next;
        slow=slow->next;
    }
    slow->next=slow->next->next;
    return head;
}

8.BM10 两个链表的第一个公共结点

题目：输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

数据范围： n \le 1000n≤1000
要求：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)

例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：

可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。

解：这道题用两个指针相同速度移动，移动到空时，在到换链表移动，相等则是公共结点。 

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param pHead1 ListNode类 
 * @param pHead2 ListNode类 
 * @return ListNode类
 */
struct ListNode* FindFirstCommonNode(struct ListNode* pHead1, struct ListNode* pHead2 ) {
    // write code here
    struct ListNode*l1=pHead1,*l2=pHead2;
    while(l1!=l2)
    {
        l1=(l1==NULL)?pHead2:l1->next;
        l2=(l2==NULL)?pHead1:l2->next;
    }
    return l1;
}

9.BM11 链表相加(二)

题目：假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。

给定两个这种链表，请生成代表两个整数相加值的结果链表。

数据范围：0 \le n,m \le 10000000≤n,m≤1000000，链表任意值 0 \le val \le 90≤val≤9
要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n)

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

 解：这道我们可以先反转链表，然后在相加，进位。很烦

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */
struct mylist{
    int cnt;
    struct ListNode *list;
};

struct ListNode *swaplist(struct ListNode *head, int *cnt)
{
    struct ListNode *cur1=head;
    struct ListNode *pre1=NULL, *nxt1=NULL;
    int count = 0;
    while(cur1)
    {
        nxt1 = cur1->next;
        cur1->next = pre1;
        pre1 = cur1;
        cur1 = nxt1;
        count++;
    }
    *cnt = count;
    return pre1;
}

/**
 * 
 * @param head1 ListNode类 
 * @param head2 ListNode类 
 * @return ListNode类
 */
struct ListNode* addInList(struct ListNode* head1, struct ListNode* head2 ) {
    // write code here
    struct mylist mylist1,mylist2;
    char flag = 0;
    int oldval=0;
    
    if(NULL == (head1 && head2))
        return head1?head1:head2;
    //获取到反转后的链表和链表长度，并保存到mylist中
    mylist1.list = swaplist(head1, &mylist1.cnt);
    mylist2.list = swaplist(head2, &mylist2.cnt);
    
    struct ListNode *pre=NULL, *nxt=NULL;
    struct ListNode *larger, *little;
    if(mylist1.cnt > mylist2.cnt){
        larger = mylist1.list;
        little = mylist2.list;
    }else{
        larger = mylist2.list;
        little = mylist1.list;
    }
    //遍历长链表
    while(larger)
    {
        if(little)//锻炼表没到尾
        {
            oldval = larger->val;
            larger->val = (little->val + oldval + flag)%10;
            //进位flag置1 否则清0
            flag = (little->val + oldval + flag >= 10) ? 1 : 0;
            little = little->next;
        }else if(flag){
            oldval = larger->val;
            larger->val = (oldval + 1)%10;
            flag = oldval+1 >= 10? 1 : 0;
        }
        
        nxt = larger->next;
        larger->next = pre;
        pre = larger;
        larger = nxt;
    }

    if(flag){
        struct ListNode *newhead = (struct ListNode *)malloc(sizeof(struct ListNode));
        newhead->next = pre;
        newhead->val = 1;
        return newhead;
    }else{
        return pre;
    }
}

10.BM12 单链表的排序

题目：给定一个节点数为n的无序单链表，对其按升序排序。

数据范围：0 < n \le 1000000<n≤100000，保证节点权值在[-10^9,10^9][−109,109]之内。

要求：空间复杂度 O(n)O(n)，时间复杂度 O(nlogn)O(nlogn)

示例1

输入：

[1,3,2,4,5]

复制返回值：

{1,2,3,4,5}

 解：双指针比较大小排序

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param head ListNode类 the head node
 * @return ListNode类
 */
struct ListNode* sortInList(struct ListNode* head ) {
    // write code here
    if(head==NULL||head->next==NULL)
        return head;
    struct ListNode *fast=head;
    struct ListNode *slow=head;
    struct ListNode *brk=NULL;
    while(fast&&fast->next)
    {
        fast=fast->next->next;
        if(fast==NULL||fast->next==NULL)
            brk=slow;
        slow=slow->next;
    }
    brk->next=NULL;
    struct ListNode*head1=sortInList(head);
    struct ListNode*head2=sortInList(slow);
    struct ListNode dummy;
    struct ListNode*cur=&dummy;
    while(head1||head2)
    {
        if(head1==NULL||(head1!=NULL&&head2!=NULL&&head1->val>head2->val))
        {
            cur->next=head2;
            head2=head2->next;
            cur=cur->next;
        }
        else
        {
            cur->next=head1;
            head1=head1->next;
            cur=cur->next;
        }
    }
    return dummy.next;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

将写好的.py/.java程序变成.exe文件

将写好的.py/.java程序变成.exe文件

目录 一、背景 1.1、前言 1.2、说明 二、优点与缺点分析 2.1、优点 2.2、缺点 三、将.py变成.exe步骤 3.1、下载需要的库 3.2、pycharm控制台.py->.exe文件 3.3、命令行.py->.exe文件 四、.py->.exe->执行.exe可能会遇到的报错与解决办法 4.1、pyinsta…
阅读更多...
第2章 ESP32 日志

第2章 ESP32 日志

ESP32 日志 UART配置 新建工程 查看->命令面板&#xff0c;输入esp-idf:new project&#xff0c;一路完成工程创建选择menuconfig&#xff0c;输入UART 输入UART 自定义波特率改为&#xff1a;460800 日志打印 ESP32的日志打印函数 ESP_LOGx分成5个等级&#xff1a;err…
阅读更多...
前端笔记总结+注册登录页案例

前端笔记总结+注册登录页案例

day 1 前端开发 目的&#xff1a;开发一个平台&#xff08;网站&#xff09; 前端开发&#xff1a;HTML、CSS、JavaScript Web框架&#xff1a;接收请求并处理 - Flask、Djiango MySQL数据库&#xff1a;存储数据的地方快速上手&#xff1a;基于Flask Web框架快速搭建一个网站…
阅读更多...
Spring Cloud Alibaba商城实战项目（day02）

Spring Cloud Alibaba商城实战项目（day02）

四、搭建Spring Cloud Alibaba环境 4.1、简介 官方文档&#xff1a;https://spring-cloud-alibaba-group.github.io/github-pages/hoxton/zh-cn/index.html 我们所选用的组件&#xff1a; SpringCloud Alibaba - Nacos&#xff1a;注册中心&#xff08;服务发现/注册&#xf…
阅读更多...
还不会二分查找？看这一篇就够了

还不会二分查找？看这一篇就够了

目录一、整数二分1.1 二分查找模板1.1.1 寻找右边界的二分查找1.1.2 寻找左边界的二分查找1.2 应用&#xff1a;寻找元素的起始位置和终止位置二、浮点数二分2.1 浮点数二分模板2.2 应用&#xff1a;数的三次方根三、使用STL进行二分查找3.1 std::binary_search3.2 std::lower_…
阅读更多...
27-Golang中的错误处理机制

27-Golang中的错误处理机制

Golang中的错误处理机制说明基本说明使用deferrecover处理上述代码错误处理机制的好处自定义错误说明 package main import ("fmt" )func test() {num1 : 10num2 : 0res : num1 / num2fmt.Println("res", res) }func fmt() {test ()fmt.Println("mai…
阅读更多...
分享77个Java源码，总有一款适合您

分享77个Java源码，总有一款适合您

Java源码 分享77个Java源码&#xff0c;总有一款适合您 下面是文件的名字&#xff0c;我放了一些图片&#xff0c;文章里不是所有的图主要是放不下...&#xff0c;大家下载后可以看到。 源码下载链接&#xff1a;https://pan.baidu.com/s/1EhB4snvWia5eCztyfiX_2A?pwdbofo …
阅读更多...
wish、亚马逊、ebay、沃尔玛自养号测评补单优势之分析技巧

wish、亚马逊、ebay、沃尔玛自养号测评补单优势之分析技巧

测评补单的资源可以说是卖家非常宝贵的财富&#xff0c;通过测评补单和广告相结合&#xff0c;可以快速有效的提升店铺的产品销量&#xff0c;提高转化&#xff0c;提升listing权重&#xff0c;如果是做自养号还可以不用担心以后被别人牵制&#xff0c;毕竟资源掌握在自己手上&…
阅读更多...
docker-基础实战第二课

docker-基础实战第二课

Docker三剑客 Docker 镜像&#xff08;Image&#xff09;&#xff1a;镜像可以用来创建容器&#xff0c;一个镜像可以创建多个容器。 容器&#xff1a;容器实例就是指实际运行的实例&#xff0c;可以理解为镜像是java的类&#xff0c;容器就是new出来的对象。 仓库&#xff1a;…
阅读更多...
elasticsearch实现基于拼音搜索

elasticsearch实现基于拼音搜索

1、背景 一般情况下&#xff0c;有些搜索需求是需要根据拼音和中文来搜索的&#xff0c;那么在elasticsearch中是如何来实现基于拼音来搜索的呢&#xff1f;可以通过elasticsearch-analysis-pinyin分析器来实现。 2、安装拼音分词器 # 进入 es 的插件目录 cd /usr/local/es/…
阅读更多...
【论文阅读 CIKM2011】Finding Dimensions for Queries

【论文阅读 CIKM2011】Finding Dimensions for Queries

文章目录ForewordAbsMethodList ExtractionList WeightingList ClusteringDimension and Item RankingForeword This paper is from CIKM2011, so we only condier the method, not resultsThere are many papers that have not been shared. More papers can be found in: Sh…
阅读更多...
微信小程序+阿里物联/Onenet物联+esp32搭建无服务器物联系统（一）---ESP32硬件设计开源

微信小程序+阿里物联/Onenet物联+esp32搭建无服务器物联系统（一）---ESP32硬件设计开源

目录 简介 一、硬件设计开源连接 二、硬件设计解析 1、电路原理图 2、PCB版图 3、BOM资料 4、整体项目的资料连接 微信小程序阿里物联平台合宙Air724UG搭建无服务器物联系统&#xff08;一&#xff09; 微信小程序阿里物联平台合宙Air724UG搭建无服务器物联系统&#xff08…
阅读更多...
uni-app canvas绘制海报流程的一些记录

uni-app canvas绘制海报流程的一些记录

绘制流程 布局定义 在我们的布局里要声明canvas的定义如下&#xff0c;可以声明class布局样式&#xff0c;width和height是必须的&#xff0c;因为如果没有就绘制不了。 canvas-id也是必须的&#xff0c;我们需要通过id找到对一个你的canvas对象&#xff0c;来做操作 <c…
阅读更多...
公测开启！CRMEB 多商户v2.1新功能快来体验

公测开启！CRMEB 多商户v2.1新功能快来体验

“ 真正实现完美主义当然很困难&#xff0c;但具备追求完美主义的态度&#xff0c;就能减少错误。” ——稻盛和夫 CRMEB 多商户 v2.1公测版正式发布&#xff01;新增付费会员&#xff0c;可进行会员折扣价管理、会员福利设置&#xff1b;新增社区发布短视频&#xff0c;打造短…
阅读更多...
Django REST framework--DRF视图

Django REST framework--DRF视图

Django REST framework--DRF视图DRF视图编写常规Django视图编写视图装饰器api_view查询资源返回所有数据返回单条数据返回json格式的数据新增资源修改资源删除资源DRF视图编写 常规Django视图编写 序列化器最终的作用是为视图提供转化后的数据&#xff0c;可使用Serializer类…
阅读更多...
【饥荒】本地服务器+内网穿透

【饥荒】本地服务器+内网穿透

本地服务器搭建方法 准备工具 网易UU加速器&#xff08;用于加速科雷官网登陆和steam创意工坊&#xff09;Don’t Starve Together Dedicated Server(steam饥荒联机版开服工具) 获取方法&#xff1a;在库中勾选工具&#xff0c;然后搜索Don’t Starve Together Dedicated Ser…
阅读更多...
Unity SRP自定义渲染管线学习1.2：初步绘制

Unity SRP自定义渲染管线学习1.2：初步绘制

绘制物体 绘制物体&#xff0c;包括不透明的物体&#xff0c;透明物体&#xff0c;再加上之前的天空盒 Camera void DrawVisibleGeometry(){//我们需要将不透明物体和透明物体分开绘制//如果我们直接先绘制所有的物体&#xff0c;然后再绘制天空盒&#xff0c;我们就会看到对…
阅读更多...
nodejs+vue家庭食谱饮食方案管理系统网站python php java

nodejs+vue家庭食谱饮食方案管理系统网站python php java

本系统分为用户和管理员两个角色&#xff0c;其中用户可以注册登陆系统&#xff0c;查看美食食谱&#xff0c;一周健康食谱安排&#xff0c;查看美食食材&#xff0c;在线交流发布帖子&#xff1b;管理员可以对食谱分类&#xff0c;食谱信息&#xff0c;材料信息&#xff0c;美…
阅读更多...
区块链技术2---BTC的数据结构

区块链技术2---BTC的数据结构

1&#xff1a;Hash pointers&#xff08;哈希指针&#xff09;和普通指针相比&#xff0c;哈希指针除了保存地址还保存哈希值2&#xff1a;Block chain区块链中的区块通过哈希指针相连&#xff0c;这里的哈希指针的哈希值是对前一个区块的整体取哈希值&#xff08;包括前一个区…
阅读更多...
linux系统中使用QT实现摄像头功能的方法

linux系统中使用QT实现摄像头功能的方法

大家好&#xff0c;今天主要和大家聊一聊&#xff0c;如何使用QT中的Camera的功能和实现。 目录 第一&#xff1a;摄像头资源简介 第二&#xff1a;环境搭建要求 第三&#xff1a;代码编译实现要求 第一&#xff1a;摄像头资源简介 开发板上有一路“CSI”摄像头接口&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023