Leetcode面T2(1-8)链表

Q2.3 删除中间节点

实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。

示例：

输入：单向链表a->b->c->d->e->f中的节点c

结果：不返回任何数据，但该链表变为a->b->d->e->f

解题思路

解法一：与后结点交换数值，然后删除后结点

​ 思路：由于只能访问当前结点，删除元素一般需要前置结点，所以可以把当前结点的值与后结点交换再删除后结点

​ 分析：时间复杂度是常数级，效率很快，不需要额外内存空间

//解法一：与后结点交换数值，再删除后结点

public static void test1(ListNode node) {

ListNode next_node = node.next;

//交换两个结点的值

int temp = next_node.val;

next_node.val = node.val;

node.val = temp;

//下面删除next_node

node.next=next_node.next;

//测试

/*while(node!=null){

System.out.println(node.val);

node=node.next;

}*/

}

方法二：

class Solution {

public void deleteNode(ListNode node) {

//删除当前节点node ，可以删去其下一个节点，

//并将下一个节点的值赋值给当前节点

node.val = node.next.val;

node.next = node.next.next;

}

}

Q2.4 分割链表

编写程序以 x 为基准分割链表，使得所有小于 x 的节点排在大于或等于 x 的节点之前。如果链表中包含 x，x 只需出现在小于 x 的元素之后(如下所示)。分割元素 x 只需处于“右半部分”即可，其不需要被置于左右两部分之间。

示例:

输入: head = 3->5->8->5->10->2->1, x = 5

输出: 3->1->2->10->5->5->8

class Solution {

/*

这个题目的意思其实是：将所有小于 x 的节点放在 x 节点之前

例如：

[1,4,3,2,5,2] 3 -> [1, 2, 2, 3, 4, 5]

[3, 5, 8, 5, 10, 2, 1] 5 -> [1, 2, 3, 5, 5, 8, 10]

方法： 双指针

cur 为遍历的当前节点。pre 为遍从前向后第一个未交换的节点

cur 向后遍历过程总若遇到小于 x 的元素 则与pre 进行交换

*/

public ListNode partition(ListNode head, int x) {

ListNode cur = head;

ListNode pre = head;

while (cur != null) {

if (cur.val < x) {

swap(cur, pre);

pre = pre.next;

}

cur = cur.next;

}

return head;

}

public void swap(ListNode p1, ListNode p2) {

int temp = p1.val;

p1.val = p2.val;

p2.val = temp;

}

}

Q2.5 链表求和

给定两个用链表表示的整数，每个节点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。

示例：

输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295

输出：2 -> 1 -> 9，即912

进阶：假设这些数位是正向存放的，请再做一遍。

示例：

输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295

输出：9 -> 1 -> 2，即912

思路：

用递归解法，分别从两个链表的第一个节点开始，取一个值相加，相加的结果对10取模，取模得到值作为结果的一位节点。重复上述操作再从两个链表的下一位取值相加( 注 意 得 加 上 前 一 次 操 作 的 进 位 ) \color{red}{(注意得加上前一次操作的进位)}(注意得加上前一次操作的进位)，结果存入结点，通过递归将这些节点连接起来。

/**

• Definition for singly-linked list.

• public class ListNode {

• int val;
  

• ListNode next;
  

• ListNode(int x) { val = x; }
  

• }

*/

class Solution {

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

//add为求和函数

ListNode res = add(l1, l2, 0);

return res;

}

//head1和head2分别为两个链表的第一个元素,value为上一次操作的进位

static ListNode add(ListNode head1,ListNode head2, int value) {

if (head1 == null && head2 == null) {

if (value == 1) {

//最后还有进位需要生成最后一个值为1的节点

return new ListNode(1);

} else {

//已完成最后一位的相加操作，开始逐层返回

return null;

}

}

if (head1 != null) {

//链表1要相加的那位不为空就把值加上

value += head1.val;

}

if (head2 != null) {

//链表2要相加的那位不为空就把值加上

value += head2.val;

}

//如果两个值相加后>=10就会产生进位，对10取模可得到减去进位的值

ListNode res = new ListNode(value % 10);

//如果两位相加的值小于10则没有进位，即进位为0

//如果两位相加的值>=10,则要向高位进1

//此处value值的意义变成了向高位的进位

value = value < 10 ? 0 : 1;

//此处的三目运算符功能是防止产生空指向异常，只有head1或者head2

//不为空的情况才下才有next节点

//传入的value值为向高位的进位

res.next = add(head1null?null:head1.next, head2null?null:head2.next, value);

return res;

}

}

Q2.6 回文链表

编写一个函数，检查输入的链表是否是回文的。

示例 1：

输入： 1->2

输出： false

示例 2：

输入： 1->2->2->1

输出： true

class Solution {

public boolean isPalindrome(ListNode head) {

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

return true;

}

//找到链表中间点

ListNode low = head;

ListNode fast = head;

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

low = low.next;

fast = fast.next.next;

}

if(fast != null){//说明有奇数个结点,low需要再走一步。

low = low.next;

}

//翻转后半段链表

ListNode cur = low.next;

low.next = null;

while(cur != null){

ListNode temp = cur.next;

cur.next = low;

low = cur;

cur = temp;

}

//比较前后段是否一致

while(low != null){

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

return false;

}

low = low.next;

head = head.next;

}

return true;

}

}

Q2.7 链表相交

给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3

输出：Reference of the node with value = 8

输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

输出：Reference of the node with value = 2

输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2

输出：null

输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。

解释：这两个链表不相交，因此返回 null。

注意：

如果两个链表没有交点，返回 null 。

在返回结果后，两个链表仍须保持原有的结构。

可假定整个链表结构中没有循环。

程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

总结：

1.这里是单项链表，不可能出现剪刀形状的相交。

2.这里的是的相交是下面的情况

3.让两个节点分别从一个链表的首部开始，走完一个链表重新走另外一个链表，如果相遇必然相交，因为走的路径都是AD+DC+BD

public class Solution {

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

if(headAnull||headBnull)

{

return null;

}

ListNode p1=headA;

ListNode p2=headB;

while(p1!=p2)

{

p1=p1==null? headB:p1.next;

p2=p2==null? headA:p2.next;

}

return p1;

}

}

Q2.8 环路检测

给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。

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

示例 1：

输入：head = [3,2,0,-4], pos = 1

输出：tail connects to node index 1

解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0

输出：tail connects to node index 0

解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1

输出：no cycle

解释：链表中没有环。

/**

• 判断链表是否有环：

• 设置快指针和慢指针，慢指针每次走一步，快指针每次走两步

• 当快指针与慢指针相等时，就说明该链表有环

*/

public boolean isRinged(Node head){

if(head == null){

return false;

}

Node slow = head;

Node fast = head;

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

slow = slow.next;

fast = fast.next.next;

if(fast == slow){

return true;

}

}

return false;

}

Q2.9  给定一个有环链表，实现一个算法返回环路的开头结点

(1)创建两个指针：FastPointer和SlowPointer。

(2)SlowPointer每走一步，FastPointer就走两步。

(3)两者碰在一起时，将SlowPointer指向LinkedListHead，FastPointer保持不变。

(4)以相同速度移动SlowPointer和FastPointer，一次一步，然后返回新的碰撞处。

LinkedListNode findBegining(LinkedListNode head) {

LinkedListNode slow = head;

LinkedListNode fast = head;

/找出碰撞处，将处于链表中LOOP_SIZE-k步的位置/

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

slow = slow.next;

fast = fast.next.next;

if(slow == fast) { // 碰撞

break;

}

}

/错误检查，没有碰撞处，也即没有回路/

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

return null;

}

/*将slow指向首部，fast指向碰撞处，两者距离环路

*起始处k步，若两者以相同速度移动，则必定会在环

路起始处碰在一起/

slow = head;

while(slow != fast) {

slow = slow.next;

fast = fast.next;

}

总结

最后小编想说：不论以后选择什么方向发展，目前重要的是把Android方面的技术学好，毕竟其实对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！

这里附上我整理的几十套腾讯、字节跳动，京东，小米，头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

由于篇幅有限，这里以图片的形式给大家展示一小部分。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

技术进阶之路很漫长，一起共勉吧~
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
if(fast == null || fast.next == null) {

return null;

}

/*将slow指向首部，fast指向碰撞处，两者距离环路

*起始处k步，若两者以相同速度移动，则必定会在环

路起始处碰在一起/

slow = head;

while(slow != fast) {

slow = slow.next;

fast = fast.next;

}

总结

最后小编想说：不论以后选择什么方向发展，目前重要的是把Android方面的技术学好，毕竟其实对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！

这里附上我整理的几十套腾讯、字节跳动，京东，小米，头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

由于篇幅有限，这里以图片的形式给大家展示一小部分。

[外链图片转存中…(img-SKsB01MA-1715789793333)]

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

技术进阶之路很漫长，一起共勉吧~
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！