当前位置：网站首页>＜代码随想录二刷＞链表
＜代码随想录二刷＞链表
2022-07-07 15:41:00 【51CTO】
文章目录
- 206. 反转链表
- 141. 环形链表
- 707. 设计链表
203. 移除链表元素
题目描述
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
示例 1：
示例 2：
示例 3：
思路分析
双指针
先为原始链表创建一个虚拟头结点(便于操作),然后定义两个指针,pre指向前一个节点,cur指向当前节点.
当前节点满足条件,则进行移除操作.
最后删除创建的虚拟头结点.
图解过程:
参考代码
#include<bits/stdc++.h>
using
namespace
std;
struct
ListNode {
int
val;
ListNode
*
next;
ListNode():
val(
0),
next(
nullptr) {}
ListNode(
int
x):
val(
x),
next(
nullptr) {}
ListNode(
int
x,
ListNode
*
next):
val(
x),
next(
nullptr) {}
};
//采用双指针
ListNode
*
removeElements(
ListNode
*
node,
int
val) {
ListNode
*
head
=
new
ListNode(
-
1,
node) ;
//定义头结点
ListNode
*
pre
=
head;
//初始化
ListNode
*
cur
=
head
->
next;
//这里也可以直接使用一个cur变量来删除节点,我们定义两个,逻辑更加清晰
ListNode
*
temp;
while(
cur
!=
NULL) {
if(
cur
->
val
==
val) {
temp
=
cur;
pre
->
next
=
cur
->
next;
cur
=
cur
->
next;
delete
temp;
}
else {
pre
=
cur;
cur
=
cur
->
next;
}
}
//删除虚拟头结点
temp
=
head
->
next;
delete
head;
return
temp;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
206. 反转链表
题目描述
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
示例 2：
示例 3：
思路分析
方法一：双指针
基本思路:从前往后将指针的方向改变,返回最后一个节点
使用pre指向前一个节点,cur代表当前节点,从第一个节点开始进行遍历,每次让cur指向pre,之后cur继续遍历下一个节点,直至链表遍历完毕.
方法二：递归（从前往后改变指针方向）
思路和方法一基本一致,递归实际上就是自己调用自己,每次的操作一致.
- 每次我们需要改变指针指向,需要操作两个节点,当前节点cur和上一个节点pre,所以这就是递归函数的参数.
- 递归的结束条件就是当前节点为NULL,则不再需要改变方向了.递归结束.
方法三：递归（从后往前改变指针方向）
参考代码
方法一：双指针
//方法一:双指针法
ListNode
*
reverseList(
ListNode
*
head) {
if(
head
==
NULL
||
head
->
next
==
NULL) {
//判断0个和1个节点情况,不用进行反转
return
head;
}
ListNode
*
pre
=
NULL,
*
cur
=
head,
*
temp
=
head
->
next;
//开始 从前往后改变指针的指向
while(
cur) {
temp
=
cur
->
next;
//保存下一个节点
cur
->
next
=
pre;
//改变指向
pre
=
cur;
//pre后移动
cur
=
temp;
//cur后移动
}
return
pre;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
方法二：递归(从前往后改变指针方向)
//方法二:递归法1 先改变指针方向,再继续进行递归
ListNode
*
reverse(
ListNode
*
pre,
ListNode
*
cur) {
//返回值主要是用来递归完成之后返回头结点的,无其他用途
if(
cur
==
NULL) {
return
pre;
}
ListNode
*
temp
=
cur
->
next;
cur
->
next
=
pre;
//修改指针方向
return
reverse(
cur,
temp) ;
}
ListNode
*
reverseList(
ListNode
*
head) {
if(
head
==
NULL
||
head
->
next
==
NULL) {
//判断0个和1个节点情况,不用进行反转
return
head;
}
return
reverse(
NULL,
head);
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
方法三：递归（从后往前改变指针方向） 目前测试不通过…
//方法三:递归法2 先进行递归,后改变指针方向 ???不知道为啥错了..
ListNode
*
resNode
=
new
ListNode(
-
1);
ListNode
*
solve(
ListNode
*
cur) {
if(
cur
==
NULL) {
//结束条件
return
resNode;
}
ListNode
*
pre
=
solve(
cur
->
next);
pre
->
next
=
cur;
return
cur;
}
ListNode
*
reverseList(
ListNode
*
head) {
if(
head
==
NULL
||
head
->
next
==
NULL) {
//判断0个和1个节点情况,不用进行反转
return
head;
}
solve(
head);
ListNode
*
head
=
resNode
->
next;
delete
resNode;
return
head;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
24. 两两交换链表中的节点
题目描述
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
示例 2：
示例 3：
思路分析
题目的要求是交换相邻的节点,题目也说了是这两个节点的顺序发生改变,而不是仅仅交换下值.而且如果当前节点只有一个,则肯定不需要交换啦.
接下来我们用图解来表示:
根据图中,我们可以使用三个辅助变量便可完成操作.
参考代码
#include<bits/stdc++.h>
using
namespace
std;
//节点定义
struct
ListNode{
int
val;
ListNode
*
next;
ListNode(){}
ListNode(
int
x):
val(
x),
next(
nullptr){
}
ListNode(
int
x,
ListNode
*
next):
val(
x),
next(
next){
}
};
ListNode
*
swapPairs(
ListNode
*
head) {
if(
head
==
NULL
||
head
->
next
==
NULL){
//没有结点或者只有一个结点时
return
head;
}
ListNode
*
dummyHead
=
new
ListNode(
-
1,
head);
//创建虚拟头结点
ListNode
*
cur
=
dummyHead,
*
node1,
*
node2,
*
node3;
//创建当前节点cur以及辅助节点node1、node2、node3
while(
cur
->
next
&&
cur
->
next
->
next){
node1
=
cur
->
next;
node2
=
cur
->
next
->
next;
node3
=
cur
->
next
->
next
->
next;
cur
->
next
=
node2;
//执行第一步:当前0节点指向2号节点
node2
->
next
=
node1;
//执行第二步:当前2节点指向1号节点
node1
->
next
=
node3;
//执行第三步:当前1节点指向3号节点.
cur
=
node1;
//更新cur
}
head
=
dummyHead
->
next;
delete
dummyHead;
return
head;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
19. 删除链表的倒数第 N 个结点
题目描述
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
示例 2：
示例 3：
思路分析
方法一:逆向思维法
删除倒数第n个节点 ==> 删除正数N-n+1个节点.
图解:(以实例一为例)
方法一:快慢指针
先搞一个虚拟头结点,方便我们接下来的操作.
- 第一步slow和fast都指向虚拟头结点.
- 第二步fast向前移动n+1个节点
- slow和fast同时向前移动,直至fast为空,则slow对应的便是目标节点的前一个节点.
图解
参考代码
方法一:逆向思维法
//方法一:逆向思维法 删除倒数第n个节点 ==> 删除正数N-n+1个节点.
ListNode
*
removeNthFromEnd(
ListNode
*
head,
int
n) {
ListNode
*
dummyHead
=
new
ListNode(
-
1,
head);
ListNode
*
cur,
*
temp;
cur
=
dummyHead
->
next;
int
N
=
0,
m;
//总结点
while(
cur) {
N
++;
cur
=
cur
->
next;
}
//删除第n个节点
m
=
N
-
n;
cur
=
dummyHead;
while(
m
--){
//指针指向第m个位置
cur
=
cur
->
next;
}
temp
=
cur
->
next;
//保存删除节点
cur
->
next
=
cur
->
next
->
next;
//进行删除
delete
temp;
// delete dummyHead;
head
=
dummyHead
->
next;
//最后的head一定要重新赋值哦,因为之前的head 可能已经挂了.
delete
dummyHead;
return
head;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
方法二:双指针法
//方法二:双指针法(快慢指针法)
ListNode
*
removeNthFromEnd(
ListNode
*
head,
int
n) {
ListNode
*
dummyHead
=
new
ListNode(
-
1,
head);
ListNode
*
slow
=
dummyHead,
*
fast
=
dummyHead,
*
temp;
//fast先走n+1步
while(
n
>=
0) {
fast
=
fast
->
next;
n
--;
}
//slow和fast同时开始走,直到fast为NULL
while(
fast
!=
NULL) {
slow
=
slow
->
next;
fast
=
fast
->
next;
}
//进行删除
temp
=
slow
->
next;
slow
->
next
=
slow
->
next
->
next;
delete
temp;
head
=
dummyHead
->
next;
delete
dummyHead;
return
head;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
面试题 02.07. 链表相交
题目描述
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
思路分析
题目的要求是求两个链表的交点,但是这里的交点是指针相等,不是节点里面的值相同.
看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点,如何求得交点呢.
我们可以求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：
此时我们就可以让CurA和CurB,从前往后遍历各自链表的节点,直到两者相等,此时对应的便是交点. 如果两个链表都遍历完还没有找到,则说明没有交点.
参考代码
#include<bits/stdc++.h>
using
namespace
std;
struct
ListNode {
int
val;
ListNode
*
next;
ListNode() {}
ListNode(
int
x):
val(
x),
next(
nullptr) {
}
ListNode(
int
x,
ListNode
*
next):
val(
x),
next(
next) {
}
};
//方法:双指针
//先求出两条链表长度,然后最长两个指针指向最短的起始位置 ,同时向后移动.知道遇到公共结点
ListNode
*
getIntersectionNode(
ListNode
*
headA,
ListNode
*
headB) {
ListNode
*
pointerA
=
headA,
*
pointerB
=
headB;
int
lenA
=
0,
lenB
=
0,
gap;
//a:b代表两条链表的长度
while(
pointerA) {
//求LenA长度
lenA
++;
pointerA
=
pointerA
->
next;
}
while(
pointerB) {
//求LenB长度
lenB
++;
pointerB
=
pointerB
->
next;
}
始终让A的长度比B大
if(
lenA
>
lenB) {
pointerA
=
headB;
pointerB
=
headA;
gap
=
lenA
-
lenB;
}
else{
pointerA
=
headA;
pointerB
=
headB;
gap
=
lenB
-
lenA;
}
while(
gap
--) {
//B指针移动到和A指针相同的位置
pointerB
=
pointerB
->
next;
}
while(
pointerA
&&
pointerB) {
//A和B一起向前移动
if(
pointerA
==
pointerB){
//如果相同则直接进行返回
return
pointerA;
}
pointerA
=
pointerA
->
next;
pointerB
=
pointerB
->
next;
}
return
NULL;
//如果没有公共结点,则返回NULL;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
141. 环形链表
题目描述
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。
示例 1：
示例 2：
示例 3：
思路分析
如何判断是否有环?:快慢指针
分别定义fast和slow指针,分别指向头结点,fast每次移动两个节点,slow每次移动一个节点,如果fast和slow指针在途中相遇,则说明这个链表有环.
这个过程就如同操场跑步一样,跑的快的人在一段时间后就会追上慢的人.
参考代码
#include<bits/stdc++.h>
using
namespace
std;
struct
ListNode {
int
val;
ListNode
*
next;
ListNode() {}
ListNode(
int
x):
val(
x),
next(
nullptr) {
}
ListNode(
int
x,
ListNode
*
next):
val(
x),
next(
next) {
}
};
bool
hasCycle(
ListNode
*
head) {
ListNode
*
slow
=
head,
*
fast
=
head;
while(
fast
!=
NULL){
fast
=
fast
->
next;
if(
fast
!=
NULL) {
fast
=
fast
->
next;
}
else{
//没有环
continue;
}
slow
=
slow
->
next;
if(
slow
==
fast){
//有环
return
true;
}
}
return
false;
//没有环
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
142. 环形链表 II
题目描述
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例 1：
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
解释：链表中没有环。
思路分析
本题主要考察:
- 判断链表是否环
- 如果有环，如何找到这个环的入口
如何判断是否有环?:快慢指针
分别定义fast和slow指针,分别指向头结点,fast每次移动两个节点,slow每次移动一个节点,如果fast和slow指针在途中相遇,则说明这个链表有环.
这个过程就如同操场跑步一样,跑的快的人在一段时间后就会追上慢的人.
如果有环，如何找到这个环的入口%22%20aria-hidden%3D%22true%22%3E%0A%20%3Cuse%20xlink%3Ahref%3D%22%23E1-MJMAIN-3F%22%20x%3D%220%22%20y%3D%220%22%3E%3C%2Fuse%3E%0A%3C%2Fg%3E%0A%3C%2Fsvg%3E)
从头结点出发一个指针index1，从相遇节点 也出发一个指针index2，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。
证明过程可以参考卡尔大佬的文章,讲的通俗易懂,嘿嘿嘿
参考代码
#include<bits/stdc++.h>
using
namespace
std;
struct
ListNode {
int
val;
ListNode
*
next;
ListNode() {}
ListNode(
int
x):
val(
x),
next(
nullptr) {
}
ListNode(
int
x,
ListNode
*
next):
val(
x),
next(
next) {
}
};
ListNode
*
detectCycle(
ListNode
*
head) {
ListNode
*
slow
=
head,
*
fast
=
head,
*
index1,
*
index2;
//首先判断有环没有环
while(
fast
!=
NULL
&&
fast
->
next
!=
NULL) {
fast
=
fast
->
next
->
next;
//fast走两步
slow
=
slow
->
next;
//slow走一步
if(
slow
==
fast) {
//此时如果相遇必定是入口节点
index1
=
head;
index2
=
slow;
//寻找环的入口
while(
index1
!=
index2) {
index1
=
index1
->
next;
index2
=
index2
->
next;
}
return
index1;
}
}
return
NULL;
//如果无环,则会退出while循环,返回NULL
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
707. 设计链表
题目描述
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
- get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
- addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
- addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
- addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
- deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
思路分析
盲猜面试出这个的可能性很大,很考查基础.
示例：
参考代码
#include<bits/stdc++.h>
using
namespace
std;
//很奇怪,按说是可以的...
class
MyLinkedList {
public:
//定义链表
struct
LinkedNode {
int
val;
LinkedNode
*
next;
LinkedNode():
val(
0),
next(
NULL) {
};
LinkedNode(
int
x):
val(
x),
next(
NULL) {
};
LinkedNode(
int
x,
LinkedNode
*
next):
val(
x),
next(
next) {
};
};
MyLinkedList() {
head
=
new
LinkedNode();
size
=
0;
}
//获取链表中 index 个节点的值。如果索引无效，则返回-1。
int
get(
int
index) {
if(
index
<
0
||
index
>
size
-
1 ) {
return
-
1;
}
LinkedNode
*
cur
=
head
->
next;
while(
index
--) {
//实际上是获得index+1个节点 ,因为index是从0开始的
cur
=
cur
->
next;
}
return
cur
->
val;
}
// 在链表头部添加节点。
void
addAtHead(
int
val) {
// ListNode *newNode = new ListNode(val,head->next);
// head->next = newNode;
head
->
next
=
new
LinkedNode(
val,
head
->
next);
size
++;
}
//链表尾部添加节点
void
addAtTail(
int
val) {
LinkedNode
*
cur
=
head;
while(
cur
->
next) {
cur
=
cur
->
next;
}
cur
->
next
=
new
LinkedNode(
val);
size
++;
}
//在链表中的第index个节点之前添加值为val 的节点。
//如果index等于链表的长度，则该节点将附加到链表的末尾
//如果 index 大于链表长度，则不会插入节点。
//如果index小于0，则在头部插入节点。
void
addAtIndex(
int
index,
int
val) {
if(
index
>
size) {
//如果 index 大于链表长度，则不会插入节点。
return;
}
if(
index
<
0) {
//如果index小于0，则在头部插入节点。
addAtHead(
val);
}
if(
index
==
size) {
//如果index等于链表的长度，则该节点将附加到链表的末尾
addAtTail(
val);
}
LinkedNode
*
cur
=
head;
while(
index
--) {
cur
=
cur
->
next;
}
cur
->
next
=
new
LinkedNode(
val,
cur
->
next);
// ListNode *newNode = new ListNode(val);
// newNode->next = cur->next;
// cur->next = newNode;
size
++;
}
//如果索引 index 有效，则删除链表中的第 index 个节点。
void
deleteAtIndex(
int
index) {
if(
index
>=
size
||
index
<
0) {
return;
}
LinkedNode
*
cur
=
head;
while(
index
--) {
cur
=
cur
->
next;
}
LinkedNode
*
temp
=
cur
->
next;
cur
->
next
=
cur
->
next
->
next;
delete
temp;
size
--;
}
void
printLinkedList(){
LinkedNode
*
cur
=
head;
while(
cur
->
next){
cout
<<
cur
->
next
->
val
<<
" ";
cur
=
cur
->
next;
}
cout
<<
endl;
}
private:
//全局变量
LinkedNode
*
head;
int
size ;
};
int
main() {
MyLinkedList
*
obj
=
new
MyLinkedList();
int
param_1
=
obj
->
get(
0);
cout
<<
param_1
<<
endl;
obj
->
addAtHead(
1);
obj
->
printLinkedList();
obj
->
addAtTail(
2);
obj
->
printLinkedList();
obj
->
addAtIndex(
1,
3);
obj
->
printLinkedList();
obj
->
deleteAtIndex(
0);
obj
->
printLinkedList();
return
0;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.
- 58.
- 59.
- 60.
- 61.
- 62.
- 63.
- 64.
- 65.
- 66.
- 67.
- 68.
- 69.
- 70.
- 71.
- 72.
- 73.
- 74.
- 75.
- 76.
- 77.
- 78.
- 79.
- 80.
- 81.
- 82.
- 83.
- 84.
- 85.
- 86.
- 87.
- 88.
- 89.
- 90.
- 91.
- 92.
- 93.
- 94.
- 95.
- 96.
- 97.
- 98.
- 99.
- 100.
- 101.
- 102.
- 103.
- 104.
- 105.
- 106.
- 107.
- 108.
- 109.
- 110.
- 111.
- 112.
- 113.
- 114.
- 115.
- 116.
- 117.
- 118.
- 119.
- 120.
- 121.
- 122.
- 123.
- 124.
备注:代码本身没啥问题,LeetCode关于这个题可能有点不严谨…
如果有收获！！！ 希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客
边栏推荐
- datepicket和timepicket，日期、时间选择器的功能和用法
- 深入浅出图解CNN-卷积神经网络
- 【TPM2.0原理及应用指南】 1-3章
- Show progress bar above window
- Audio device strategy audio device output and input selection is based on 7.0 code
- Solidity 开发环境搭建
- L1-028 判断素数（Lua）
- How to mount the original data disk without damage after the reinstallation of proxmox ve?
- Functions and usage of viewflipper
- 第3章业务功能开发(安全退出)
猜你喜欢
深入浅出【机器学习之线性回归】
textSwitch文本切换器的功能和用法
DevOps 的运营和商业利益指南
麒麟信安操作系统衍生产品解决方案 | 存储多路径管理系统，有效提高数据传输可靠性
Vscode three configuration files about C language
![[video / audio data processing] Shanghai daoning brings you elecard download, trial and tutorial](/img/14/4e7ebfb1ed5b99f8377af9d17d2177.jpg)
[video / audio data processing] Shanghai daoning brings you elecard download, trial and tutorial
请将磁盘插入“U盘(H)“的情况＆无法访问 磁盘结构损坏且无法读取
Functions and usage of tabhost tab
What is cloud computing?
麒麟信安中标国网新一代调度项目！
随机推荐
Actionbar navigation bar learning
Create dialog style windows with popupwindow
使用 xml资源文件定义菜单
【TPM2.0原理及应用指南】 16、17、18章
【信息安全法律法規】複習篇
如何在软件研发阶段落地安全实践
LeetCode 890（C＃）
Problems encountered in Jenkins' release of H5 developed by uniapp
How to choose the appropriate automated testing tools?
状态模式 - Unity（有限状态机）
Notification is the notification displayed in the status bar of the phone
【OKR目标管理】价值分析
LeetCode1051（C＃）
第1章CRM核心业务介绍
Show progress bar above window
Lex & yacc of Pisa proxy SQL parsing
Matplotlib绘制三维图形
imageswitcher的功能和用法
redis主从、哨兵主备切换搭建一步一步图解实现
责任链模式 - Unity