LeetCode 008 链表系列
Posted Al_tair
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode 008 链表系列相关的知识，希望对你有一定的参考价值。
链表(一)
大家好！我是小笙！征程栈与递归(一)让我尤为忧为揪心！我先做链表题推进进度，大家一起加油呀!!
链表(一)系列系题型如下
链表系列一
链表的删除（203,19）
203. 移除链表元素
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
提示：
列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50。
方法一：递归（MyCode）
链表的定义具有递归的性质，因此链表题目常可以用递归的方法求解
解题思路:
递归的终止条件是 head 为空，此时直接返回null。当 head 不为空时，递归地进行删除操作，然后判断head 的节点值是否等于 val 并决定是否要删除head。
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode removeElements(ListNode head, int val)
if(head == null) return null;
if(val<1 || val>50) return head;
ListNode list = head;
if(head.val != val)
list.val = head.val;
list.next = removeElements(head.next,val);
return list;
else
list = removeElements(head.next,val);
return list;
执行用时：1 ms, 在所有 Java 提交中击败了96.34%的用户
内存消耗：40.2 MB, 在所有 Java 提交中击败了5.04%的用户
// 上述代码可以优化 省略变量list链表创建和使用
class Solution
public ListNode removeElements(ListNode head, int val)
if (head == null)
return head;
head.next = removeElements(head.next, val);
return head.val == val ? head.next : head;
方法二：迭代(Other’s Code)
核心算法
temp.next=temp.next.next
class Solution
public ListNode removeElements(ListNode head, int val)
ListNode dummyHead = new ListNode(0); // 头节点 不存数据
dummyHead.next = head;
ListNode temp = dummyHead;
while (temp.next != null)
if (temp.next.val == val)
temp.next = temp.next.next;
else
temp = temp.next;
return dummyHead.next;
19. 删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
方法一：遍历（MyCode）
解题思路:
一种容易想到的方法是，我们首先从头节点开始对链表进行一次遍历，得到链表的长度 length。随后我们再从头节点开始对链表进行一次遍历，当遍历到第 length-n+1个节点时，它就是我们需要删除的节点。
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode removeNthFromEnd(ListNode head, int n)
if(head == null) return null;
ListNode testLength = head;
int length = 0; // 记录链表长度
while(testLength != null)
length++;
testLength = testLength.next;
testLength = head;
length = length-n+1; // 记录要删除的第length个节点
// 删除第一个节点
if(length==1)
testLength = testLength.next;
return testLength;
// 删除第一个节点以外的节点
while(testLength != null)
length--;
if(length == 1)
testLength.next = testLength.next.next;
testLength = testLength.next;
return head;
执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗：36.2 MB, 在所有 Java 提交中击败了85.25%的用户
链表的旋转与反转（206）
206. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
方法一：入栈出栈（MyCode）
反向输出链表不难让我们想到入栈出栈的方式
解题思路无非就是入栈与出栈
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode reverseList(ListNode head)
ListNode list = new ListNode(0);
list = head;
if(head == null || head.next == null) return head;
Stack<Integer> stack = new Stack<>();
// 入栈
while(head != null)
stack.push(head.val);
head = head.next;
head = list;
// 出栈
while(!stack.empty())
list.val = stack.pop();
list = list.next;
return head;
执行用时：1 ms, 在所有 Java 提交中击败了5.50%的用户
内存消耗：38.1 MB, 在所有 Java 提交中击败了71.40%
方法二：生成新链表（Other’sCode）
解题思路：
1.创建链表list
2.遍历head链表，反向添加链表结点的方式生成一个倒序链表
// list = new ListNode(x.val,list ); 精髓
class Solution
public ListNode reverseList(ListNode head)
ListNode list = null;
for (ListNode x = head; x != null; x = x.next)
list = new ListNode(x.val,list );
return list;
方法三：迭代（Other’sCode）
在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用
/*
重点思路：
1.curr.next和链表中的curr.next没有关系 和 curr当下的指向有关系
2.分成前一个结点prev 当前结点curr 后一个结点next
3.改变前一个结点和当前结点的指向，改成当前结点指向前一个结点
4.依次后移一个节点（注意移动的顺序）
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
*/
class Solution
public ListNode reverseList(ListNode head)
ListNode prev = null;
ListNode curr = head;
while (curr != null)
ListNode next = curr.next;
curr.next = prev;
prev = curr;
curr = next;
return prev;
链表高精度加法（445）
445. 两数相加 II
给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]
示例2：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[8,0,7]
示例3：
输入：l1 = [0], l2 = [0]
输出：[0]
提示：
链表的长度范围为 [1, 100]
0 <= node.val <= 9
输入数据保证链表代表的数字无前导 0
方法一：反转相加（MyCode）
一图让你理解代码
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode addTwoNumbers(ListNode l1, ListNode l2)
if(l1.val == 0) return l2;
else if(l2.val == 0) return l1;
int carryDigit = 0; // 进位符号
int addNodeNum = 0; // 添加节点的数
l1 = reverseList(l1);
l2 = reverseList(l2);
ListNode head = new ListNode(0);
ListNode hou = new ListNode(0);
head.next = hou;
while(l1 != null || l2 != null || carryDigit != 0)
if(l1 == null && l2 == null)
addNodeNum = carryDigit%10;
carryDigit = carryDigit/10;
else if(l1 == null)
addNodeNum = (l2.val+carryDigit)%10;
carryDigit = (l2.val+carryDigit)/10;
l2 = l2.next;
else if(l2 == null)
addNodeNum = (l1.val+carryDigit)%10;
carryDigit = (l1.val+carryDigit)/10;
l1 = l1.next;
else
addNodeNum = (l2.val+l1.val+carryDigit)%10;
carryDigit = (l2.val+l1.val+carryDigit)/10;
l1 = l1.next;
l2 = l2.next;
hou.next = new ListNode(addNodeNum); // 新节点
hou = hou.next;
head.next =head.next.next;
head.next = reverseList(head.next);
return head.next;
// 反转链表的值，不改变结点
public ListNode reverseList(ListNode head)
ListNode list = null;
for (ListNode x = head; x != null; x = x.next)
list = new ListNode(x.val,list );
return list;
执行用时：2 ms, 在所有 Java 提交中击败了99.18%的用户
内存消耗：38.7 MB, 在所有 Java 提交中击败了58.20%的用户
链表的合并
21.合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4]
示例 2：输入：l1 = [], l2 = [] 输出：[]
示例 3：输入：l1 = [], l2 = [0] 输出：[0]
提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100 l1 和 l2 均按 非递减顺序 排列
方法一：遍历（MyCode）
解题思路：
- 创建两个结点 head，hou 分别 用于返回的链表头和遍历添加结点
- 分三种情况进行添加结点 结束条件为遍历完传入进来的两个链表
- 最后返回链表
/**
* Definition for singly-linked list.
* public class ListNode
* int val;
* ListNode next;
* ListNode()
* ListNode(int val) this.val = val;
* ListNode(int val, ListNode next) this.val = val; this.next = next;
*
*/
class Solution
public ListNode mergeTwoLists(ListNode l1, ListNode l2)
ListNode head = new ListNode(0);
ListNode hou = head;
while(l1 != null || l2 != null)
if(l1 == null)
hou.next = l2;
break;
else if(l2 == null)
hou.next = l1;
break;
else
if(l1.val > l2.val)
hou.next = l2;
l2 = l2.next;
else
hou.next = l1;
l1 = l1.next;
hou = hou.next;
return head.next;
以上是关于LeetCode 008 链表系列的主要内容，如果未能解决你的问题，请参考以下文章