链表题不会做？lc经典链表算法最细解题思路+源码

}
//2.中的和大的连接
if (eB != null) {
eE.next = bB;
}
return sB != null ? sB : eB != null ? eB : bB;
}

6、复制含有随机指针节点的链表

【题目描述】

【要求】

如果链表的长度为 N, 时间复杂度达到 O(N)。

【解答】

方法一：使用额外的存储空间

这道题的难点在于我们需要定位好随机指针，一个比较简单的解法就是把原节点与复制的节点关联起来，可以使用哈希表把他们关联起来。

首先把副节点全部创建出来，然后把原节点与对应的副节点用哈希表关联起来。关联的时候原节点作为key，副节点作为value。例如对于链表 1->2->3->null。创建副节点 1’, 2’, 3’。然后用哈希表关联起来：

key | value —|— 1 | 1’ 2 | 2’ 3 | 3’

之后在把所有副节点连接成一个链表。在连接的时候，我们 可以通过哈希表很容易这找到对应的随机节点。

代码如下

//方法1：采用哈希表
public static Node1 copyListWithRand(Node1 head) {
Map<Node1, Node1> map = new HashMap<>();
Node1 cur = head;
while (cur != null) {
map.put(cur, new Node1(cur.value));
cur = cur.next;
}
//把副节点连接起来
cur = head;
while (cur != null) {
map.get(cur).next = map.get(cur.next);
map.get(cur).rand = map.get(cur.rand);
cur = cur.next;
}
return map.get(head);
}

这种方法的时间复杂度为 O(n), 空间复杂度也为 O(n)。

方法2

其实我们也可以不需要哈希表来辅助，也就是说 ，我们是可以做到空间复杂度为 O(1)的，我们可以把复制的副节点插入到原链表中去，这样也能把原节点与副节点进行关联，进而 定位到随机节点。例如，对于链表 1->2->3->null。首先生成副节点 1’, 2’, 3。然后把副节点插入到原节点的相邻位置，即把原链表变成 1->1’->2->2’->3->3’->null。

这样我们也可以在连接副节点的时候，找到相应的随机节点。例如 1 的随机节点是 3，则 1’ 的随机节点是 3’。显然，1节点的随机节点的下一个节点就是 1’的随机节点。具体代码如下：

//方法二
public static Node1 copyListWithRand2(Node1 head){
Node1 cur = head;
Node1 next = null;

//把复制的节点插进去
while (cur != null) {
next = cur.next;
Node1 temp = new Node1(cur.value);//复制节点
temp.next = cur.next;
cur.next = temp;
cur = next;
}
//在一边把复制的节点取出来一边连接。
cur = head;
next = null;
while (cur != null) {
next = cur.next.next;//保存原链表的下一个节点
cur.next.next = next != null ? next.next : null;
cur.next.rand = cur.rand != null ? cur.rand.next : null;
cur = next;
}
return head.next;
}

采用这种方法的时候，由于随机节点有可能是空指针，随意写代码的时候要注意。

7、将单链表的每K个节点之间逆序

【题目描述】

给定一个单链表的头节点head, 实现一个调整单链表的函数，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。

例如：

链表:1->2->3->4->5->6->7->8->null, K = 3。

调整后：3->2->1->6->5->4->7->8->null。其中 7，8不调整，因为不够一组。

【要求】

如果链表的长度为 N, 时间复杂度达到 O(N)。

【解答】

这道题我们可以用递归来实现，假设方法reverseKNode()的功能是将单链表的每K个节点之间逆序。reverse()方法的功能是将一个单链表逆序。

那么对于下面的这个单链表，其中 K = 3。

我们把前K个节点与后面的节点分割出来：

temp指向的剩余的链表，可以说是原问题的一个子问题。我们可以调用reverseKNode()方法将temp指向的链表每K个节点之间进行逆序。再调用reverse()方法把head指向的那3个节点进行逆序，结果如下：

接着，我们只需要把这两部分给连接起来就可以了。最后的结果如下：

如果不大理解，看下代码可能就比较好理解了。

代码如下

//每k个节点为一组的逆转
public static Node reverseKNodes(Node head, int k) {
if (head == null || head.next == null) {
return head;
}
Node cur = head;
for (int i = 1; cur != null && i < k; i++) {
cur = cur.next;
}
//判断是否能组成一组。
if (cur == null) {
return head;
}
//temp指向剩余的链表
Node temp = cur.next;
cur.next = null;
//把k个节点进行反转
Node newHead = reverse(head);
//把之后的部分链表进行每K个节点逆转转
Node newTemp = reverseKNodes(temp, k);
//把两部分节点连接起来
return newHead;
}

//单链表逆序
public static Node reverse(Node head) {
if (head == null || head.next == null) {
return head;
}
Node newHead = reverse(head.next);
head.next.next = head;
head.next = null;
return newHead;
}

当然，这道题一个很简单的做法就是利用栈来辅助，每K个节点入栈就把这K个节点出栈连接成一个链表，之后剩余再在进栈…

不过这种做法的额外空间复杂度是O(K)。

8、将搜索二叉树转换成双向链表

【题目描述】

对于二叉树的节点来说，有本身的值域，有指向左孩子和右孩子的两个指针；对双向链表的节点来说，有本身的值域，有指向上一个节点和下一个节点的指针。在结构上，两种结构有相似性，现有一棵搜索二叉树，请将其转为成一个有序的双向链表。 　 节点定义：

class Node2{
public int value;
public Node2 left;
public Node2 right;

public Node2(int value) {
this.value = value;
}
}

例如：

这棵二叉搜索树转换后的双向链表从头到尾依次是 1～9。对于每一个节点来说，原来的 right 指针等价于转换后的 next 指针，原来的 left 指针等价于转换后的 last 指针，最后返回转换后的双向链表的头节点。

【要求】

如果链表的长度为 N, 时间复杂度达到 O(N)

【解答】

方法一：采用队列辅助

如果用一个队列来辅助的话，还是挺容易。采用中序遍历的方法，把二叉树的节点全部放进队列，之后在逐一弹出来连接成双向链表。

代码如下

public static Node2 convert1(Node2 head) {
Queue queue = new LinkedList<>();
//将节点按中序遍历放进队列里
inOrderToQueue(head, queue);
head = queue.poll();
Node2 pre = head;
pre.left = null;
Node2 cur = null;
while (!queue.isEmpty()) {
cur = queue.poll();
pre.right = cur;
cur.left = pre;
pre = cur;
}
pre.right = null;
return head;
}

private static void inOrderToQueue(Node2 head, Queue queue) {
if (head == null) {
return;
}
inOrderToQueue(head.left, queue);
queue.offer(head);
inOrderToQueue(head.right, queue);
}

这种方法的时间复杂度为 O(n), 空间复杂度也为 O(n)。

方法2：通过递归的方式

在之前打卡的9道题中，几乎超过一般都用到了递归，如果这些题目使用的递归大家都理解了，并且能够自己独立写出代码了，那么我相信大家对递归的思想、使用已经有一定的熟练性。

我们假设函数conver的功能就是把二叉树变成双向链表，例如对于这种一棵二叉树：

经过conver转换后变成这样：

注意，转换之后，把最右边节点的right指针指向了最左边的节点的。

对于下面这样一颗二叉树：

采用conver函数分别对左右子树做处理，结果如下：

之后，再把他们连接起来

了解了基本原理之后，直接看代码吧。

public static Node2 conver(Node2 head) {
if (head == null) {
return head;
}
Node2 leftE = conver(head.left);
Node2 rightE = conver(head.right);
Node2 leftB = leftE != null ? leftE.right : null;
Node2 rightB = rightE != null ? rightE.right : null;
if (leftE != null && rightE != null) {

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

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

如何做好面试突击，规划学习方向？

面试题集可以帮助你查漏补缺，有方向有针对性的学习，为之后进大厂做准备。但是如果你仅仅是看一遍，而不去学习和深究。那么这份面试题对你的帮助会很有限。最终还是要靠资深技术水平说话。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。建议先制定学习计划，根据学习计划把知识点关联起来，形成一个系统化的知识体系。

学习方向很容易规划，但是如果只通过碎片化的学习，对自己的提升是很慢的。

我们搜集整理过这几年字节跳动，以及腾讯，阿里，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

我们在搭建这些技术框架的时候，还整理了系统的高级进阶教程，会比自己碎片化学习效果强太多

很难做到真正的技术提升。建议先制定学习计划，根据学习计划把知识点关联起来，形成一个系统化的知识体系。

学习方向很容易规划，但是如果只通过碎片化的学习，对自己的提升是很慢的。

我们搜集整理过这几年字节跳动，以及腾讯，阿里，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

[外链图片转存中…(img-gqIdp91o-1712037897476)]

我们在搭建这些技术框架的时候，还整理了系统的高级进阶教程，会比自己碎片化学习效果强太多

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录