LeetCode 008 链表系列

Posted 2021-12-10 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 链表系列的主要内容，如果未能解决你的问题，请参考以下文章

LeetCode系列160. 相交链表

817. Linked List Components - LeetCode

Java系列008和你一起揭开LinkedList的“庐山真面目”

Leetcode算法系列（链表）之删除链表倒数第N个节点

Leetcode题解 - 链表简单部分题目代码+思路（21832032062419876）

日常系列LeetCode《15·链表2》