DS：经典算法OJ题（1）

   

                     

创作不易，友友们给个三连呗！！

     本文为经典算法OJ题练习，大部分题型都有多种思路，每种思路的解法博主都试过了（去网站那里验证）是正确的，大家可以参考！！

一、移除元素（力扣）

经典算法OJ题：移除元素

思路1：遍历数组，找到一个元素等于val，就把后面的所有元素往前挪，类似顺序表实现中的指定位置删除！

//思路1：遍历数组，找到一个元素等于val，就把后面的所有元素往前挪，类似顺序表实现中的指定位置删除！
int removeElement(int* nums, int numsSize, int val)
{for (int i = 0; i < numsSize; i++)//用来遍历{if (nums[i] == val)//要挪动，而且是从前往后挪{for (int j = i; j < numsSize - 1; j++)nums[j] = nums[j + 1];//从前往后挪numsSize--;//挪完长度-1i--;//挪动后新的数据还在原来的位置，所以不能让i往前走！！}}return numsSize;
}

思路2：（双指针法）利用双指针，第一个指针引路，第二个指针存放想要的元素（不等于val的元素）（较优）

//思路2：（双指针法）利用双指针，第一个指针引路，第二个指针存放想要的元素（不等于val的元素）
int removeElement(int* nums, int numsSize, int val)
{int src = 0;//用来探路，src即原操作数int dst = 0;//用来存放想要的数据，dst即目标操作数while (src < numsSize){if (nums[src] == val){src++;//找到val就src走}else{nums[dst] = nums[src];//dst接收想要的数据//找不到就两个都走dst++;src++;}}//此时dst恰好就是数组的新长度return dst;
}

二、合并两个有序数组（力扣）

经典算法OJ题：合并两个有序数组

思路1：num2全部存储到num1中，再统一进行排序（qsort）

int int_cmp(const void* p1, const void* p2)//比较方法
{return (*(int*)p1 - *(int*)p2);//返回值来影响qsort
}void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{int i = m;//指向数组1后面的空位置int j = 0;//指向数组2while (i < m + n){nums1[i] = nums2[j];i++;j++;}//循环结束说明插入完成，使用快速排序qsort(nums1, m + n, sizeof(int), int_cmp);
}

思路2：合并的时候顺便排序，利用3个指针，l1用来遍历数组1，l2用来遍历数组2，比大小之后的数据用l3记录。（较优）

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{int l1=m-1;//从1数组的最后一个有效数据往前int l2=n-1;//从2数组的最后一个有效数据往前int l3=n+m-1;//从1数组的最后一个元素开始往前while(l1>=0 && l2>=0)//l1和l2其中一个遍历完就得跳出循环{//从后往前比大小
if(nums1[l1]>nums2[l2])nums1[l3--]=nums1[l1--];
elsenums1[l3--]=nums2[l2--];}//循环结束后，有两种情况，一种是l1先遍历完，此时l2要接着插进去，//另一种是l2先遍历完，此时l1就不需要处理了while(l2>=0)nums1[l3--]=nums2[l2--]; 
}

三、移除链表元素（力扣）

经典算法OJ题：移除链表元素

思路1：遍历原链表，遇到val就删除，类似单链表的指定位置删除

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) 
{//考虑头节点就是val的情况while(head!=NULL&&head->val==val)head=head->next;//此时头节点不可能是val//当链表为空if(head==NULL)return head;//当链表不为空时ListNode*pcur=head;//用来遍历链表ListNode*prev=NULL;//用来记录前驱结点while(pcur){//当找到val时if(pcur->val==val){prev->next=prev->next->next;//前驱结点指向pucr的下一个结点free(pcur);//删除的结点被释放pcur=prev->next;//继续指向新的结点}//没找到val时else{prev=pcur;//往后走之前记录前驱结点pcur=pcur->next;//pcur往前遍历}}return head;
}

思路2：定义一个不带头新链表，将不为val的结点尾插进去

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) 
{ListNode*pcur=head;//用来遍历链表//定义新链表的头尾指针ListNode*newhead=NULL;//用来记录头ListNode*newtail=NULL;//用来尾插新链表while(pcur)
{if(pcur->val!=val)//不满足val则插入到新链表{//一开始链表是空的if(newhead==NULL)newhead=newtail=pcur;//链表不为空了，开始尾插else{newtail->next=pcur;//尾插newtail=newtail->next;//尾插后向后挪动}}pcur=pcur->next;//pcur要遍历往后走
}
//插入完后要加NULL！还要避免newtail是空的情况
if(newtail)
newtail->next=NULL;
return newhead;
}

思路3：给原链表创造一个哨兵结点，然后遍历，遇到val就删（和思路1比较，多了一个哨兵，稍优于思路1）

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) 
{ListNode*newhead=(ListNode*)malloc(sizeof(ListNode));//创建一个新的哨兵节点newhead->next=head;//哨兵接头ListNode*pcur=head;//用来遍历链表ListNode*prev=newhead;//记录前驱结点
while(pcur)
{//遇到了，开始删除
if(pcur->val==val)
{prev->next=pcur->next;free(pcur);pcur=prev->next;
}
//如果没遇到val，都往后走
else
{prev=pcur;pcur=pcur->next;
}
}
//循环结束，删除完成
ListNode*ret=newhead->next;//释放哨兵结点前记住需要返回的结点
free(newhead);
newhead=NULL;
return ret;
}

思路4：定义一个带头新链表，将不为val的结点尾插进去（和思路2相比较，多了一个哨兵）（较优）

typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) 
{ListNode*newhead,*newtail;newhead=newtail=(ListNode*)malloc(sizeof(ListNode));//创建一个新的哨兵节点ListNode*pcur=head;//用来遍历链表while(pcur){if(pcur->val!=val){//找打不为val的值  开始尾插newtail->next=pcur;newtail=newtail->next;}pcur=pcur->next;//没找到就往后找}newtail->next=NULL;ListNode*ret=newhead->next;//释放哨兵时记住返回值free(newhead);newhead=NULL;return ret;
}

四、反转链表（力扣）

经典算法OJ题：反转链表

思路1：利用带头单链表头插法，建立一个新的带头结点的单链表L,扫描head链表的所有结点，每扫描一个结点就创造一个s结点并将值赋给s结点然后头插法插入新链表L中，得到的就是逆序的head链表

 typedef struct ListNode ListNode;ListNode*BuyNode(int x)//封装创建新结点的函数{ListNode*newnode=(ListNode*)malloc(sizeof(ListNode));newnode->next=NULL;newnode->val=x;return newnode;}
struct ListNode* reverseList(struct ListNode* head)
{ListNode*pcur=head;//用来遍历ListNode*newhead=BuyNode(-1);//创建哨兵结点ListNode*temp=NULL;//充当临时变量while(pcur)
{temp=BuyNode(pcur->val);//创建新结点接收pur的值//头插temp->next=newhead->next;newhead->next=temp;//pcur往后走pcur=pcur->next;//pcur往后走
}
ListNode*ret=newhead->next;//哨兵位释放之前保存头节点
free(newhead);
newhead=NULL;
return ret;
}

思路2：利用带头单链表头插法，建立一个新的带头结点的单链表L,扫描head链表的所有结点，每扫描一个结点就头插法插入新链表L中，得到的就是逆序的head链表（相比思路1多了个哨兵，稍优于思路1）

 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head)
{//如果链表为空if(head==NULL)return head;//如果链表不为空ListNode*newhead,*newtail;//一个哨兵，一个记录尾巴方便后面置NULL；newhead=(ListNode*)malloc(sizeof(ListNode));//创建哨兵结点newhead->next=head;//哨兵和原来的头节点连接起来newtail=head;//newtail记住一开始的head，方便后面连接NULLListNode*pcur=head->next;//pcur用来遍历(从第二个)ListNode*temp=NULL;//用来记录下一个遍历点while(pcur){temp=pcur->next;//连接前，先记住下一个结点的位置//头插 插在哨兵结点和原来头结点的中间newhead->next=pcur;pcur->next=head;head=pcur;//头插进来的成为哨兵结点后面的新头pcur=temp;//pcur从原先链表的下一个结点开始继续遍历}newtail->next=NULL;//要记得给尾巴结点连接NULL；free(newhead);newhead=NULL;return head;
}

思路3：利用不带头链表头插法，扫描head链表的所有结点，每扫描一个结点就头插法插入新链表L中，得到的就是逆序的head链表(较优)

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head)
{//如果链表为空if(head==NULL)return head;//如果链表不为空ListNode*pcur=head->next;//用来遍历ListNode*ptail=head;//用来记录尾巴，方便后面置NULL；ListNode*temp;//记录遍历的结点while(pcur){temp=pcur->next;//头插到head前面
pcur->next=head;
head=pcur;
pcur=temp;}ptail->next=NULL;return head;
}

思路4：利用3个指针，分别记录前驱结点、当前结点、后继结点，改变原链表的指针指向(最优)

 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head)
{//链表为空的时候if(head==NULL)return head;//链表不为空的时候，创建3个指针，分别指向前驱、当前、后继结点
ListNode*p1,*p2,*p3;
p1=NULL;//前驱
p2=head;//当前
p3=head->next;//后继
while(p2)
{//改变指向
p2->next=p1;
//向后挪动
p1=p2;
p2=p3;
//考虑p3为NULL的时候
if(p3)
p3=p3->next;
}
return p1;
}

五、合并两个有序链表（力扣）

经典算法OJ题：合并两个有序链表

思路1：创建一个哨兵节点，双指针判断两组数据的大小，因为是把 list2 的节点插入 list1 ，所以只要当 list1 指向的数大于 list2 的数，就把当前 list2 节点插入 list1 的前面。循环判定条件，只要双指针中有一个为空就跳出循环，即有一个指针到了节点末端。若 list1 先结束，表示剩下 list2 的数都比 list1 里的数大，直接把 list2 放到 list1后即可若 list2 先结束，即表示已经合并完成。

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{ListNode*newhead=(ListNode*)malloc(sizeof(ListNode));//创建一个新的哨兵结点newhead->next=list1;//哨兵点与list1相连接ListNode*p1=list1;//利用p1遍历链表1ListNode*p2=list2;//利用p2遍历链表2ListNode*prev=newhead;//prev记录前驱结点ListNode*temp=NULL;//充当临时变量,暂时保存list2的指向while(p1&&p2)//p1和p2有一个为NULL了就必须跳出循环{
if(p1->val>p2->val)//list2插入list1该元素前面
{temp=p2->next;//记住p2指针的遍历点//尾插prev->next=p2;p2->next=p1;//尾插完成往前走prev=p2;p2=temp;
}
//找不到时，prev和p1都往后走
else
{p1=p1->next;prev=prev->next;
}}
//跳出循环后有两种可能，一种是p1先为NULL，一种是p2先为NULL
//此时prev恰好走到尾结点
//如果p2为NULL，说明已经结束！如果p1为NULL，此时尾插p2在prev后面
if(p1==NULL)
prev->next=p2;
ListNode*ret=newhead->next;//哨兵位要释放，返回前要记录newhead->next
free(newhead);
newhead=NULL;
return ret;
}

思路2：定义一个带头新链表（方便返回），两个指针分别指向两组数组，逐个比较，较小的尾插到新的链表中，循环判断条件，只要有一个指针为NULL就跳出循环，无论是 list1 结束还是 list2 结束，只需要把剩下的部分接在新链表上即可。（较优）

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{ListNode*newhead,*newptail;newhead= newptail=(ListNode*)malloc(sizeof(ListNode));//创建一个新的哨兵结点//newptail是用来尾插的ListNode*p1=list1;//利用p1遍历链表1ListNode*p2=list2;//利用p2遍历链表2while(p1&&p2)//p1和p2有一个为NULL了就必须跳出循环{
if(p1->val<p2->val)
{newptail->next=p1;//尾插newptail=newptail->next;//插入后newptail往后走p1=p1->next;//插入后p1往后走
}
else
{newptail->next=p2;//尾插newptail=newptail->next;//插入后newptail往后走p2=p2->next;//插入后p2往后走
}}
//跳出循环后有两种可能，一种是p1先为NULL，一种是p2先为NULL
//在newtail后面插入不为NULL的链表。
newptail->next=(p1==NULL?p2:p1);
ListNode*ret=newhead->next;//哨兵位要释放，返回前要记录newhead->next
free(newhead);
newhead=NULL;
return ret;
}

六、链表的中间结点（力扣）

经典算法OJ题：链表的中间结点

思路1：统计链表中结点的个数，然后除以2找到中间结点

typedef  struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head)
{int count=0;//用来记录总共的结点数量ListNode*pcur=head;//用来遍历while(pcur){pcur=pcur->next;count++;}//此时计算出count，除以2count=count/2;//此时count代表中间结点的位置while(count){head=head->next;count--;}return head;
}

思路2：（快慢指针法），创建两个指针一开始都指向头节点，一个一次走一步，一个一次走两步，当快指针为NULL时，慢指针指向的就是中间的位置（较优）

typedef  struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head)
{
ListNode*fast,*slow;
fast=slow=head;//都指向头结点
while(fast!=NULL&&fast->next!=NULL)//存在一个就得跳出循环
//而且顺序不能反！！！因为与运算符从前往后运算
{fast=fast->next->next;//走两步slow=slow->next;//走一步
}
//循环结束slow正好指向中间结点
return slow;
}

七、分割链表（力扣）

经典算法OJ题：分割链表

思路1：创建一个新链表，遍历原链表，小的头插，大的尾插。

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x)
{//链表为空if(head==NULL)return head;//链表不为空
ListNode*pcur,*newtail;
pcur=newtail=head;//pcur用来遍历 newtail用来尾插
while(pcur)
{ListNode * temp=pcur->next;if(pcur->val<x){
//头插pcur->next=head;head=pcur;//pcur成为新的头}
//尾插else{newtail->next=pcur;newtail=newtail->next;}pcur=temp;//继续遍历
}
newtail->next=NULL;
return head;
}

思路2：创建两个新链表，遍历原链表，大的尾插大链表，小的尾插小链表，最后合并在一起。

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x)
{if(head==NULL)return head;ListNode*bighead,*bigtail,*smallhead,*smalltail;bighead=bigtail=(ListNode*)malloc(sizeof(ListNode));//大链表哨兵smallhead=smalltail=(ListNode*)malloc(sizeof(ListNode));//小链表哨兵ListNode*pcur=head;//pcur用来遍历while(pcur){if(pcur->val<x)//尾插小链表{smalltail->next=pcur;smalltail=smalltail->next;}else//尾插大链表{bigtail->next=pcur;bigtail=bigtail->next;}pcur=pcur->next;//继续往下走}//遍历完成，连接大小链表smalltail->next=bighead->next;bigtail->next=NULL;ListNode*ret=smallhead->next;//记住返回值free(bighead);free(smallhead);return ret;
}

八、环形链表的约瑟夫问题（牛客）

经典算法OJ题：环形链表的约瑟夫问题

思路：创建一个不带头的单向链表，每逢m就删除

typedef struct ListNode ListNode;
ListNode * BuyNode(int x)//创建结点的函数
{
ListNode *newnode=(ListNode *)malloc(sizeof(ListNode));
newnode->next=newnode;
newnode->val=x;
return newnode;
}
int ysf(int n, int m ) {// write code here//创建一个不带头的单向循环链表ListNode *phead=BuyNode(1);//创建一个头节点ListNode *ptail=phead;//用来遍历for(int i=2;i<=n;i++){ptail->next=BuyNode(i);ptail=ptail->next;}//创建完后要首尾相连ptail->next=phead;ListNode *pcur=phead;//pcur用来遍历ListNode *prev=NULL;//用来记录前驱结点int count=1;//用来数数while(pcur->next!=pcur)//结束条件是场上只剩下一个人{if(count==m){//指定位置删除prev->next=pcur->next;free(pcur);pcur=prev->next;count=1;//重新数}else{prev=pcur;pcur=pcur->next;count++;}
}
//此时pcur是场上唯一还在的结点
return pcur->val;
}

九、总结

1、顺序表背景的OJ题较为简单，因为顺序表底层是数组，有连续存放的特点，一方面指针运算偏移比较容易（可以多往指针的方向思考），另一方面就是我可以根据下标去拿到我想要的元素，无论是从前遍历还是从后遍历还是从中间都很方便！所以解题思路容易一些，而单链表只能通过指向，并且非双向的链表想从后面或者中间遍历会比较吃力！

2、顺序表背景的题，如果涉及到指定位置插入或者是指定位置删除，需要大量挪动数据，多层for循环比较麻烦，有时候可以往指针运算去思考！

3、链表背景的题，涉及到有关中间结点的，一般是快慢指针！！

4、关于链表的头插，如果是两个链表根据情况插入到一个新链表的头插，那么创建一个哨兵位结点会比较容易点，因为这样可以避免一开始就得换头结点。如果是在原链表的基础上头插，因为原链表是存在头节点的，这个时候不设哨兵位就会简单点，因为可以直接换头。

5、关于链表的尾插，一般需要设置一个tail指针往后遍历。

6、关于链表的指定位置插入或删除，需要记录前驱结点，这个时候需要除了需要考虑头节点为NULL的情况，还要考虑链表只有一个结点的情况，因为这个时候也没有前驱结点，这个时候如果运用哨兵就不需要考虑只有一个结点的情况，因为哨兵位可以充当头结点的前驱结点。

7、哨兵链表容易记住起始地址

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

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

相关文章

常用芯片学习——LM2596芯片

常用芯片学习——LM2596芯片

LM2596 3A降压型稳压器 使用说明 LM2596开关电压调节器是降压型电源管理单片集成电路&#xff0c;能够输出最大3A的驱动电流&#xff0c;同时具有很好的线性和负载调节特性。芯片按照输出版本可分为四种&#xff0c;分别是3.3V、5V、12V、ADJ&#xff08;可调版本&#xff09…
阅读更多...
一文读懂Python中的映射

一文读懂Python中的映射

python中的反射功能是由以下四个内置函数提供&#xff1a;hasattr、getattr、setattr、delattr&#xff0c;改四个函数分别用于对对象内部执行&#xff1a;检查是否含有某成员、获取成员、设置成员、删除成员。 获取成员: getattr class Foo:def __init__(self, name, age):se…
阅读更多...
【command】使用nr简化npm run命令

【command】使用nr简化npm run命令

参考文章 添加 alias nrnpm run通过alias启动命令可以帮助我们节省运行项目输入命令的时间 $ cd ~ $ vim .bash_profile $ source ~/.bashrc
阅读更多...
应急响应-流量分析

应急响应-流量分析

在应急响应中&#xff0c;有时需要用到流量分析工具&#xff0c;。当需要看到内部流量的具体情况时&#xff0c;就需要我们对网络通信进行抓包&#xff0c;并对数据包进行过滤分析&#xff0c;最常用的工具是Wireshark。 Wireshark是一个网络封包分析软件。网络封包分析软件的…
阅读更多...
isctf---crypto

isctf---crypto

夹里夹气 可以发现是摩斯密码 得到flag easy_rsa nc连接 rsa_d nc连接 计算d 七七的欧拉 task import gmpy2 import libnum from crypto.Util.number import *flagbISCTF{*************} mbytes_to_long(flag)plibnum.generate_prime(1024) elibnum.generate_prime(51…
阅读更多...
NPDP证书：让你的职业生涯飞升！

NPDP证书：让你的职业生涯飞升！

&#x1f31f;没错&#xff01;NPDP证书正在成为产品经理们的“新宠”&#xff01;越来越多的同行们纷纷选择考取NPDP证书&#xff0c;为什么这么火爆&#xff1f;一起来探究下吧&#xff01; &#x1f680;NPDP认证&#xff1a;产品经理的国际通行证 &#x1f4cd;NPDP&#x…
阅读更多...
快速掌握PHP：用这个网站，让学习变得简单有趣！

快速掌握PHP：用这个网站，让学习变得简单有趣！

介绍&#xff1a;PHP是一种广泛使用的开源服务器端脚本语言&#xff0c;特别适合Web开发。 PHP&#xff0c;全称为Hypertext Preprocessor&#xff0c;即超文本预处理器&#xff0c;是一种嵌入在HTML中的服务器端脚本语言。它主要用于管理动态内容和数据库交互&#xff0c;使得…
阅读更多...
【GAMES101】Lecture 09 纹理贴图 点查询与范围查询 Mipmap

【GAMES101】Lecture 09 纹理贴图 点查询与范围查询 Mipmap

目录 纹理贴图 纹理放大-双线性插值 点采样纹理所带来的问题 Mipmap 各向异性过滤 纹理贴图 我们在之前的着色里面说过如何给物体上纹理&#xff0c;就是对于已经光栅化的屏幕点&#xff0c;就是每个像素的中心&#xff0c;去寻找对应纹理的映射位置的纹理颜色&#xff0…
阅读更多...
Redis系列-数据结构篇

Redis系列-数据结构篇

数据结构 string&#xff08;字符串&#xff09; redis的字符串是动态字符串&#xff0c;类似于ArrayList&#xff0c;采用预分配冗余空间的方式减少内存的频繁分配。 struct SDS<T>{ T capacity; T len; byte flags; byte[] content; } 当字符串比较短时&#xff0c…
阅读更多...
【Apache POI】百万级数据导出Excel，并含有折线等图表

【Apache POI】百万级数据导出Excel，并含有折线等图表

需求概要 最近接到一个需求&#xff0c;概要来讲就是实现百万级数据导出Excel&#xff0c;并根据其中的数据项自动生成折线图等图表。经技术调研&#xff0c;针对内存、性能等要素&#xff0c;Apache POI此技术可完成此需求。 Apache POI是Apache软件基金会的开放源码函式库&am…
阅读更多...
MySQL 覆盖索引

MySQL 覆盖索引

目录 一、什么是索引 二、索引的有哪些种类&#xff1f; 三、InnoDB的不同的索引组织结构是怎样的呢&#xff1f; 四、什么是覆盖索引 五、如何使用是覆盖索引&#xff1f; 六、如何确定数据库成功使用了覆盖索引呢 总结&#xff1a; 一、什么是索引 索引&#xff08;在 …
阅读更多...
Redis高级特性

Redis高级特性

文章目录 1.4.1 Redis的缓存过期淘汰策略1.4.1.1 Redis内存满了怎么办1.4.1.2 过期策略1.4.1.3 缓存淘汰策略1.4.1.3.1 Redis 中LRU设计1.4.1.3.2 Redis 中LFU设计 1.4.2 持久化机制1.4.2.1 持久化流程1.4.2.2 RDB1.4.2.3 AOF1.4.2.3.1 AOF运行原理1.4.2.3.2 AOF文件重写原理 1…
阅读更多...
PowerBI商业智能分析引入，带你了解什么是商务智能

PowerBI商业智能分析引入，带你了解什么是商务智能

一、商务智能工具 什么是Power BI &#xff1f;Power Bl是微软开发的一个软件&#xff0c;它是从获取数据、数据清洗、数据图表搭建、数据分析、共享发布为一体的软件&#xff0c;无论你的数据是简单的Excel电子表格&#xff0c;还是复杂庞大的数据库&#xff0c;Power Bl都可…
阅读更多...
智慧文旅：提升旅游体验与推动经济发展的新动力

智慧文旅：提升旅游体验与推动经济发展的新动力

一、智慧文旅的定义与意义 智慧文旅&#xff0c;即智慧文化旅游&#xff0c;是一种以当地特色文化元素为核心驱动&#xff0c;利用现代科技手段实现旅游景区全面智慧升级的旅游模式。其意义在于为游客提供高效便捷的旅游信息化服务&#xff0c;提升旅游体验&#xff0c;同时推…
阅读更多...
Go语言基础之单元测试

Go语言基础之单元测试

1.go test工具 Go语言中的测试依赖go test命令。编写测试代码和编写普通的Go代码过程是类似的&#xff0c;并不需要学习新的语法、规则或工具。 go test命令是一个按照一定约定和组织的测试代码的驱动程序。在包目录内&#xff0c;所有以_test.go为后缀名的源代码文件都是go …
阅读更多...
【Linux】Linux权限的概念 -- 详解

【Linux】Linux权限的概念 -- 详解

一、Linux 中的用户 Linux 下有两种用户&#xff1a; 超级用户&#xff08;root&#xff09;&#xff1a;可以在 Linux 系统下做任何事情&#xff0c;不受限制。普通用户&#xff1a;在 Linux 下做有限的事情。 超级用户的命令提示符是 “#”&#xff0c;普通用户的命令提示符…
阅读更多...
解读BEVFormer，新一代自动驾驶视觉工作的基石

解读BEVFormer，新一代自动驾驶视觉工作的基石

文章出处 BEVFormer这篇文章很有划时代的意义&#xff0c;改变了许多视觉领域工作的pipeline[2203.17270] BEVFormer: Learning Birds-Eye-View Representation from Multi-Camera Images via Spatiotemporal Transformers (arxiv.org)https://arxiv.org/abs/2203.17270 BEV …
阅读更多...
ESP8266 控制之 : 使用 RingBuffer USART1 和 USART3互传

ESP8266 控制之 : 使用 RingBuffer USART1 和 USART3互传

简介 使用Buffer来避免数据的丢失, 或许你自己在使用串口进行收发时会丢失数据, 现在我们就来简单使用一下RingBuffer创建Rx、Tx的Buffer来避免发送接收丢包或数据丢失问题。 扩展知识 RingBuffer的介绍, 看完大概也就知道了&#xff0c;实在不知道就看看下面的代码 线路连接…
阅读更多...
使用antdesign3.0、echarts制作固定资产后台管理系统原型

使用antdesign3.0、echarts制作固定资产后台管理系统原型

学了半个月Axure,周末用半天时间&#xff0c;照着网上的模板做了一个固定资产后台管理系统的原型。重点是内联框架的使用&#xff0c;和对echarts表格js代码的调试。原型链接&#xff1a;https://qoz5rv.axshare.com 资产管理系统
阅读更多...
SD NAND的CLK引脚的注意事项和走线规范

SD NAND的CLK引脚的注意事项和走线规范

CLK的作用和注意事项 SD NAND的时钟引脚&#xff08;CLK&#xff09;的作用是提供一个时钟信号&#xff0c;用于同步数据传输。时钟信号是由主设备&#xff08;如微控制器或存储控制器&#xff09;提供的&#xff0c;用于确保SD NAND和主设备之间的数据交换是按照相同的时序进…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023