LeetCode通关：听说链表是门槛，这就抬脚跨门而入

最新推荐文章于 2024-07-25 11:15:54 发布

2401_83916204

最新推荐文章于 2024-07-25 11:15:54 发布

阅读量622

点赞数 17

分类专栏：程序员文章标签： leetcode 链表算法

本文链接：https://blog.csdn.net/2401_83916204/article/details/138459318

版权

程序员专栏收录该内容

551 篇文章 1 订阅

订阅专栏

ListNode cur = head;

ListNode prev = head;

while (cur != null) {

ListNode temp = cur.next;

//删除节点

if (cur.val == val) {

//头节点

if (cur == head) {

head = temp;

}

//非头节点

if (cur != head) {

prev.next = cur.next;

}

} else {

prev = cur;

}

cur = temp;

}

return head;

}

⏰ 时间复杂度：O(n)。

🏠 空间复杂度：O(1)。

这道题，还有一个更巧妙一点的做法，就是虚拟头指针——虚拟头指针是链表算法题中非常好用的一个技巧。

💡 思路：

可以设置一个虚拟的头指针，让它的next指向头节点，这样头节点的删除就和普通节点是一致的了。

虚拟头指针

代码如下：

/**

@return cn.fighter3.linked_list.ListNode
@Description: 203. 移除链表元素
@author 三分恶
@date 2021/7/25 10:08

public ListNode removeElements(ListNode head, int val) {

if (head == null) {

return null;

}

//虚拟头节点

ListNode dummy = new ListNode(-1, head);

ListNode prev = dummy;

ListNode cur = head;

while (cur != null) {

if (cur.val == val) {

prev.next = cur.next;

} else {

prev = cur;

}

cur = cur.next;

}

return dummy.next;

}

🚗 时间复杂度：O(n)。

🏠 空间复杂度：O(1)。

LeetCode707. 设计链表

☕ 题目：707. 设计链表 (https://leetcode-cn.com/problems/design-linked-list/)

❓ 难度：中等

📕 描述：设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();

linkedList.addAtHead(1);

linkedList.addAtTail(3);

linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3

linkedList.get(1); //返回2

linkedList.deleteAtIndex(1); //现在链表是1-> 3

linkedList.get(1); //返回3

提示：

所有val值都在 [1, 1000] 之内。
操作次数将在 [1, 1000] 之内。
请不要使用内置的 LinkedList 库。

💡 思路：

这是一道大题。

链表基本操作的图示在前面已经给出了。

比较简练的方式是设置一个伪头节点，保证链表永不为空，这样操作起来会方便很多。

但是，我本人看过一点Java链表的代码，所以不想采用这种方式。

PS：这里踩了一个坑，没仔细审题，链表index是从0开始的，导致思考5分钟，AC两小时。

好了，我们直接看代码：

/**

@Author: 三分恶
@Date: 2021/7/25
@Description: 707. 设计链表
https://leetcode-cn.com/problems/design-linked-list/
链表界节点是 0——index

**/

public class MyLinkedList {

//链表元素的个数

int size;

//头结点

ListNode head;

/**

初始化链表

public MyLinkedList() {

size = 0;

}

/**

获取第index个节点的数值

public int get(int index) {

//非法参数

if (index < 0 || index >= size) {

return -1;

}

ListNode cur = head;

for (int i = 0; i < index; i++) {

cur = cur.next;

}

return cur.val;

}

/**

在链表最前面插入一个节点

public void addAtHead(int val) {

addAtIndex(0, val);

}

/**

在链表的最后插入一个节点

public void addAtTail(int val) {

addAtIndex(size, val);

}

/**

在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
如果 index 大于链表的长度，则返回空

public void addAtIndex(int index, int val) {

//非法参数

if (index > size) {

return;

}

if (index < 0) {

index = 0;

}

//如果链表为空，直接作为头节点

if (size == 0) {

head = new ListNode(val);

size++;

return;

}

//插入

size++;

ListNode addNode = new ListNode(val);

//插入头节点之前

if (index == 0) {

addNode.next = head;

head = addNode;

return;

}

//找到前驱节点

ListNode pre = head;

for (int i = 0; i < index - 1; i++) {

pre = pre.next;

}

addNode.next = pre.next;

pre.next = addNode;

}

/**

删除第index个节点

public void deleteAtIndex(int index) {

if (index < 0 || index > size-1) {

return;

}

size–;

//头节点

if (index == 0) {

head = head.next;

return;

}

//非头节点

ListNode prev = head;

for (int i = 0; i < index - 1; i++) {

prev = prev.next;

}

//删除节点

prev.next = prev.next.next;

}

⏰时间复杂度：

addAtHead： O(1)
addAtInder，get，deleteAtIndex: O(n)。
addAtTail：O(n)。

🏠空间复杂度：所有的操作都是 O(1)。

虚拟头指针，以及双链表的实现，这里就留个白了。

双指针解决的题目

==========================================================================

剑指 Offer 22. 链表中倒数第k个节点

☕ 题目：剑指 Offer 22. 链表中倒数第k个节点 (https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/)

❓ 难度：简单

📕 描述：输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

题目示例

💡 思路：

这道题可以用双指针的办法。

以示例说明，一个指针pre在前，先跑1步，一个指针after在后，跟着跑，pre到头的时候，刚好afer是倒数第二个。

倒数第k个节点

代码实现：

/**

剑指 Offer 22. 链表中倒数第k个节点
@param head
@param k
@return

public ListNode getKthFromEnd(ListNode head, int k) {

if (head == null) {

return null;

}

ListNode preNode = head, afterNode = head;

int step = 0;

while (preNode!=null) {

preNode = preNode.next;

step++;

if (step > k) {

afterNode = afterNode.next;

}

return afterNode;

}

⏰ 时间复杂度：O(n)。

LeetCode876. 链表的中间结点

☕ 题目：876. 链表的中间结点 (https://leetcode-cn.com/problems/middle-of-the-linked-list/)

❓ 难度：简单

📕 描述：给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

💡 思路：

和上一道题有点类似。

上一道题是两个指针分先、后。

这道题可以两个指针分快、慢。

一示例1为例，fast指针跑两步，slow指针跑一步，fast指针恰好跑的是slow的两倍，fast指针跑到头了，slow指针不就恰好跑到中间了嘛！

链表的中间节点

代码如下：

/**

1. 链表的中间结点
@param head
@return

public ListNode middleNode(ListNode head) {

if (head == null) {

return null;

}

//定义快慢指针

ListNode fastNode = head, slowNode = head;

while (fastNode != null && fastNode.next != null) {

//快指针走两步

fastNode = fastNode.next.next;

//慢指针走一步

slowNode = slowNode.next;

}

return slowNode;

}

⏰ 时间复杂度：O(n)。

LeetCode19. 删除链表的倒数第 N 个结点

☕ 题目：19. 删除链表的倒数第 N 个结点 (https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)

❓ 难度：中等

📕 描述：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

**进阶：**你能尝试使用一趟扫描实现吗？

题目示例

💡 思路：

这道题上手是不是就觉得很熟？

这是 203.移除链表元素 和 剑指 Offer 22. 链表中倒数第k个节点的结合。

那么解法，我们同样可以结合这两道题。

快慢指针找到倒数第N个节点
虚拟头指针辅助删除

删除倒数第N个节点

代码如下：

/**

@return cn.fighter3.linked_list.ListNode
@Description: 19. 删除链表的倒数第 N 个结点
@author 三分恶
@date 2021/7/25 17:17

public ListNode removeNthFromEnd(ListNode head, int n) {

if (head == null) {

return null;

}

//快慢指针

ListNode fast = head, slow = head;

//虚拟头节点

ListNode dummy = new ListNode(-1);

dummy.next = head;

//一个指针从虚拟头节点开始跑

ListNode preSlow = dummy;

//计算步数

int step = 0;

while (fast != null) {

//fast先走n步

fast = fast.next;

step++;

//slow开始移动

if (step > n) {

slow = slow.next;

preSlow = preSlow.next;

}

//找到倒数第n个节点，和它的前驱

preSlow.next = slow.next;

return dummy.next;

}

⏰ 时间复杂度：O(n)。

剑指 Offer 52. 两个链表的第一个公共节点

☕ 题目：876. 链表的中间结点 (https://leetcode-cn.com/problems/middle-of-the-linked-list/)

❓ 难度：简单

📕 描述：给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

题目示例

💡 思路：

他们都说这道题浪漫，我却不想听什么狗屁的浪漫爱情故事，我只想搞钱。

这道题可以用双指针解决，定义两个指针，当某一指针遍历完链表之后，然后掉头去另一个链表的头部，继续遍历。因为速度相同所以他们第二次遍历的时候肯定会相遇。

如图（来自参考[3]）：

图片来自参考[3]

代码实现：

/**

剑指 Offer 52. 两个链表的第一个公共节点
@param headA
@param headB
@return

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

if (headA == null || headB == null) {

return null;

}

//定义两个节点

ListNode nodeA = headA, nodeB = headB;

while (nodeA != nodeB) {

//没到头就后移，到头，就指向另一树头结点

if (nodeA != null) {

nodeA = nodeA.next;

} else {

nodeA = headB;

}

//另一个节点也一样

if (nodeB != null) {

nodeB = nodeB.next;

} else {

nodeB = headA;

}

return nodeA;

}

⏰ 时间复杂度：O(m+n)，m和n分别为两个链表的长度。

160. 相交链表、面试题 02.07. 链表相交和这道题基本是一模一样的。

LeetCode206. 反转链表

☕ 题目：206. 反转链表 (https://leetcode-cn.com/problems/reverse-linked-list/)

❓ 难度：简单

📕 描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

题目示例

💡 思路：

这是一道非常经典的题目。翻转怎么做呢？

遍历链表，将当前节点的后继指向当前。

反转链表

在这里我们要额外引入两个指针：

一个prev表示前趋，用于反转时候后继的指向。
一个temp用于临时存储下一个节点，这个temp是用来干什么的？用来遍历，因为反转之后，原来的next节点已经指向prev了。

说真的，作为一个C语言菜鸡，我又想起了被指针数组、数组指针支配的日子，所以我画了一个作为Java程序员理解的示意图，如有不当之处，请指出。

反转链表

也找到了一张动图（参考[1])：

在这里插入图片描述

代码如下：

/**

1. 反转链表
@param head
@return

public ListNode reverseList(ListNode head) {

ListNode prev = null;

ListNode current = head;

while (current != null) {

//保存下一个节点

ListNode temp = current.next;

//修改当前节点后继指向

current.next = prev;

//修改前趋节点

prev = current;

current = temp;

}

return prev;

}

⏰ 时间复杂度：O(n)。

LeetCode92. 反转链表 II

☕ 题目：92. 反转链表 II (https://leetcode-cn.com/problems/reverse-linked-list-ii/)

❓ 难度：中等

📕 描述：给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。

题目示例

💡 思路：

反转链表经常容易忘，我们再做一道进阶的题目来巩固一下。

这道题什么思路呢？

我们可以把反转的这一部分拆出来，作为新的链表，反转新链表，然后再和前后的节点重新连接。

反转链表-II

代码实现：

/**

@return ListNode
@Description: 92. 反转链表 II
@author 三分恶
@date 2021/7/24 0:32

public ListNode reverseBetween(ListNode head, int left, int right) {

//虚拟头节点

ListNode dummy = new ListNode(-1);

dummy.next = head;

ListNode cur = dummy;

//一、获取被截取的子链表的前、后节点

//移动到左节点前一个节点

int i = 0;

for (; i < left - 1; i++) {

cur = cur.next;

}

//保存左节点的前一个节点

ListNode leftPre = cur;

//移动到right节点

for (; i < right; i++) {

cur = cur.next;

}

//保存右节点的后一个节点

ListNode rightAfter = cur.next;

//二、截取子链表

//切断右节点后的部分

cur.next = null;

//左节点作为子链表头节点

ListNode sonHead = leftPre.next;

//切断左节点前的部分

leftPre.next = null;

//三、反转子链表

ListNode rNode = reverseList(sonHead);

//四：重新连接

leftPre.next = rNode;

sonHead.next = rightAfter;

return dummy.next;

}

/**

@return ListNode
@Description: 反转链表
@author 三分恶
@date 2021/7/25 10:06

ListNode reverseList(ListNode head) {

ListNode prev = null;

ListNode cur = head;

while (cur != null) {

ListNode temp = cur.next;

cur.next = prev;

prev = cur;

cur = temp;

}

return prev;

}

⏰ 时间复杂度：O(n)。

LeetCode234. 回文链表

☕ 题目：234. 回文链表(https://leetcode-cn.com/problems/palindrome-linked-list/)

❓ 难度：简单

📕 描述：请判断一个链表是否为回文链表。

题目示例

💡 思路：

要是双向链表就好了，直接一个指针从头到尾，一个指针从尾到头，但是这是一个单链表。

所以我们可以用一个列表先把之给存起来，再用双指针分别从两头遍历比较。

代码如下：

/**

1. 回文链表
将值复制到集合
@param head
@return

public boolean isPalindrome(ListNode head) {

if (head == null) {

return false;

}

List nodes = new ArrayList<>(16);

//将链表的值放入集合

while (head != null) {

nodes.add(head.val);

head = head.next;

}

//双向遍历集合

int start = 0, end = nodes.size() - 1;

while (start < end) {

if (!nodes.get(start).equals(nodes.get(end))) {

return false;

}

start++;

end–;

}

return true;

}

⏰ 时间复杂度：O(n)，其中 n 指的是链表的元素个数，。

🏠 空间复杂度：O(n)，其中 n 指的是链表的元素个数，因为我们用了一个ArrayList来存储数据。

但是题目里还提出了一个进阶：

你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

既然空间复杂度O(1)，那么就不能引入新的存储结构。

还是上面那句话，要是双向链表就好了，我们就双向比较。

所以，考虑一下，我们可以把链表的后半段翻转一下，然后再比较。

回文链表

为了完成这个目的，大概需要分三步：

找到中间结点
翻转链表后半段
前半段和后半段比较

所以这种做法就是 876. 链表的中间结点 和 206. 反转链表 的组合。

代码实现如下：

/**

1. 回文链表
快慢指针法
@param head
@return

public boolean isPalindrome(ListNode head) {

//找到中间节点

ListNode midNode = findMid(head);

//翻转链表

ListNode tailHead = reverseList(midNode);

//比较

while (tailHead != null) {

if (head.val != tailHead.val) {

return false;

}

head = head.next;

tailHead = tailHead.next;

}

return true;

}

/**

找到中间节点
@param head
@return

ListNode findMid(ListNode head) {

ListNode fast = head, slow = head;

while (fast != null && fast.next != null) {

fast = fast.next.next;

slow = slow.next;

}

return slow;

}

/**

翻转链表
@param head
@return

ListNode reverseList(ListNode head) {

ListNode current = head;

ListNode prev = null;

while (current != null) {

//保存下一个节点

ListNode temp = current.next;

//修改当前节点后继指向

current.next = prev;

//修改前趋节点

prev = current;

current = temp;

}

return prev;

}

⏰ 时间复杂度：O(n)。

🏠 空间复杂度：O(1)。

LeetCode141. 环形链表

☕ 题目：141. 环形链表 (https://leetcode-cn.com/problems/linked-list-cycle/)

❓ 难度：简单

📕 描述：

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。

💡 思路：

这道题是经典的快慢指针，一个指针跑的块，一个指针跑的慢，如果链表成环的话，慢指针一定会追上快指针。

幻形链表

代码如下：

/**

@return boolean
@Description: 141. 环形链表
@author 三分恶
@date 2021/7/25 20:16

public boolean hasCycle(ListNode head) {

if (head == null) {

return false;

}

//定义快慢指针

ListNode fast = head, slow = head;

//遍历链表

while (fast != null && fast.next != null) {

//快指针移动两步

fast = fast.next.next;

//慢指针移动一步

slow = slow.next;

//快、慢指针相遇

if (fast == slow) {

return true;

}

return false;

}

⏰ 时间复杂度：O(n)。

LeetCode142. 环形链表 II

☕ 题目：142. 环形链表 II (https://leetcode-cn.com/problems/linked-list-cycle-ii/)

❓ 难度：中等

📕 描述：

给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：

你是否可以使用 O(1) 空间解决此题？

题目示例

💡 思路：

这道题，乍一看，是 141. 环形链表 的进阶，仔细一看，没那么简单。

141. 环形链表快指针只管追慢指针，不管在哪追上就行，但这个不行，我们要返回追上的节点。

怎么办？

我们可以用一个集合把链表节点存进去，要是成环的话，放入的节点肯定会有重复的。

这个集合用什么呢？用HashSet比较合适。

/**

@return cn.fighter3.linked_list.ListNode
@Description: 142. 环形链表 II
@author 三分恶
@date 2021/7/25 20:40

public ListNode detectCycle(ListNode head) {

if (head == null) {

return null;

}

HashSet set = new HashSet<>(16);

while (head != null) {

//判断set中是否包含当前元素

if (set.contains(head)) {

return head;

}

//添加元素

set.add(head);

//继续迭代

head = head.next;

}

return null;

}

⏰ 时间复杂度：O(n)。

🏠 空间复杂度：O(n)。

我们看到进阶里提到了空间复杂度O(1)，这就涉及到非常巧妙的一个双指针做法。

下图是一种比较典型的情况下，做的推导[4]：

双指针法环形链表 [4]

代码实现：

/**

@return cn.fighter3.linked_list.ListNode
@Description: 142. 环形链表 II
@author 三分恶
@date 2021/7/25 20:52

public ListNode detectCycle(ListNode head) {

if (head == null || head.next == null) {

return null;

}

//定义快、慢指针

ListNode fast = head, slow = head;

while (fast != null && fast.next != null) {

fast = fast.next.next;

slow = slow.next;

//快慢指针相遇

if (fast == slow) {

//快指针重回head

fast = head;

while (slow != fast) {

fast = fast.next;

slow = slow.next;

}

return fast;

}

return null;

}

⏰ 时间复杂度：O(n)。

🏠 空间复杂度：O(1)。

双链表问题

=======================================================================

LeetCode86. 分隔链表

☕ 题目：86. 分隔链表 (https://leetcode-cn.com/problems/partition-list/)

❓ 难度：中等

📕 描述：

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

💡 思路：

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
/img-blog.csdnimg.cn/img_convert/48b00fac285ef83c78654f04dbccd8c6.png)

代码实现：

/**

@return cn.fighter3.linked_list.ListNode
@Description: 142. 环形链表 II
@author 三分恶
@date 2021/7/25 20:52

public ListNode detectCycle(ListNode head) {

if (head == null || head.next == null) {

return null;

}

//定义快、慢指针

ListNode fast = head, slow = head;

while (fast != null && fast.next != null) {

fast = fast.next.next;

slow = slow.next;

//快慢指针相遇

if (fast == slow) {

//快指针重回head

fast = head;

while (slow != fast) {

fast = fast.next;

slow = slow.next;

}

return fast;

}

return null;

}

⏰ 时间复杂度：O(n)。

🏠 空间复杂度：O(1)。

双链表问题

=======================================================================

LeetCode86. 分隔链表

☕ 题目：86. 分隔链表 (https://leetcode-cn.com/problems/partition-list/)

❓ 难度：中等

📕 描述：

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有小于 x 的节点都出现在大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

💡 思路：

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-qfMA4PnE-1714869449920)]

[外链图片转存中…(img-09F6hm7O-1714869449921)]

[外链图片转存中…(img-tC2ibPEc-1714869449921)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2401_83916204

关注

17
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
LeetCode通关：听说链表是门槛，这就抬脚跨门而入

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
复制链接

扫一扫