【数据结构与算法 | 灵神题单 | 合并链表篇】力扣2, 21, 445, 2816

Mephisto.java2024-09-15 10:15

1. 力扣2：两数相加

1.1 题目：

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

复制代码 
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

复制代码 
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

复制代码 
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

  • 每个链表中的节点数在范围 [1, 100] 内
  • 0 <= Node.val <= 9
  • 题目数据保证列表表示的数字不含前导零

1.2 思路：

看注释，比较简单。

1.3 题解：

java 复制代码 
/**
 * 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 == null && l2 == null){
            return null;
        }
        ListNode p1 = l1;
        ListNode p2 = l2;
        // 两个指针从两个链表分别开始遍历
        // 将L1作为主链表
        while(p1 != null && p2 != null){
            // 开始一轮遍历直接把L2的值加到L1上即可
            p1.val = p1.val + p2.val;
            // 如果L1的长小于等于L2，则把L2多余的一段给L1
            if(p1.next == null){
                p1.next = p2.next;
                break;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        p1 = l1;
        // 再次遍历，如果遇到大于等于10的节点，将这个节点的值-10
        // 如果这个点的下一个节点不为null，则它的next节点+1
        // 否则new一个节点即可
        while(p1 != null){
            if(p1.val >= 10){
                p1.val -= 10;
                if(p1.next != null){
                    p1.next.val += 1;
                }else{
                    p1.next = new ListNode(1, null);
                }
            }
            p1 = p1.next;
        }
        return l1;

    }
}

2. 力扣21：合并两个有序链表

2.1 题目：

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

复制代码 
输入：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 均按 非递减顺序 排列

2.2 思路：

看注释，题目也比较简单。

2.3 题解：

java 复制代码 
/**
 * 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 list1, ListNode list2) {
        // 特殊情况先列出来
        if(list1 == null && list2 == null){
            return null;
        } else if(list1 == null){
            return list2;
        }else if (list1 == null){
            return list1;
        }
        
        ListNode dummy = new ListNode(-1, null);
        ListNode p = dummy;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                p.next = list1;
                p = p.next;
                list1 = list1.next;
            }else{
                p.next = list2;
                p = p.next;
                list2 = list2.next;
            }
        }
        // 如果list1和list2都为null，此时走第一个if循环没啥问题
        if(list1 == null){
            p.next = list2;
        } else if (list2 == null){
            p.next = list1;
        }
        return dummy.next;
    }

}

3. 力扣445：两数相加2

3.1 题目:

给你两个 非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

示例1：

复制代码 
输入：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

**进阶：**如果输入链表不能翻转该如何解决？

3.2 思路：

反转链表，让数字高位变成低位，然后低位开始相加。

3.3 题解：

java 复制代码 
/**
 * 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) {
        // 先将两个链表反转过来，让高位变成低位
        l1 = reverse(l1);
        l2 = reverse(l2);
        ListNode p = l1;
        // 同是数字低位才可以相加
        while(l1 != null && l2 != null){
            l1.val = l1.val + l2.val;
            // 如果l1的长度小于等于L2
            // 把L2多余的部分接到L1上
            if(l1.next == null){
                l1.next = l2.next;
                break;
            }
            l1 = l1.next;
            l2 = l2.next;
        }
        ListNode p_copy = p;
        // p_copy遍历链表，把节点值超过10的值更新一下
        // 如果有下一个节点，则把下一个节点的值+1，否则new一个节点
        while(p_copy != null){
            if(p_copy.val >= 10){
                p_copy.val -= 10;
                if(p_copy.next != null){
                    p_copy.next.val++;
                }else{
                    p_copy.next = new ListNode(1, null);
                }
            }
            p_copy = p_copy.next;
        }
        // 再反转链表，把低位变成高位。
        return reverse(p);
    }
    // 反转链表方法
    private ListNode reverse(ListNode head) {
        // 新链表的哨兵节点
        ListNode dummy = new ListNode(10086, null);
        // 头插法
        while(head != null){
            ListNode p = head.next;
            head.next = dummy.next;
            dummy.next = head;
            head = p;
        }
        return dummy.next;
    }
}

4. 力扣2816：翻倍以链表形式表示的数字

4.1 题目：

你一个 非空 链表的头节点 head ，表示一个不含前导零的非负数整数。

将链表 翻倍 后，返回头节点head。

示例 1：

复制代码 
输入：head = [1,8,9]
输出：[3,7,8]
解释：上图中给出的链表，表示数字 189 。返回的链表表示数字 189 * 2 = 378 。

示例 2：

复制代码
复制代码 
输入：head = [9,9,9]
输出：[1,9,9,8]
解释：上图中给出的链表，表示数字 999 。返回的链表表示数字 999 * 2 = 1998

提示：

  • 链表中节点的数目在范围 [1, 104] 内
  • 0 <= Node.val <= 9
  • 生成的输入满足：链表表示一个不含前导零的数字，除了数字 0 本身。

4.2 思路：

看注释：可以将整个链表和*2转化为将每个节点的值翻倍。然后再处理每个节点的值是否超过了10，超过了则需要处理。

4.3 题解：

java 复制代码 
/**
 * 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 doubleIt(ListNode head) {
        if(head == null){
            return null;
        }
        // 将整个链表节点的和*2 -> 将原链表的每个节点值*2
        ListNode p =head;
        while(p != null){
            p.val *= 2;
            p = p.next;
        }
        // 将链表倒置,为了让低位数字向高位数字进位
        head = reverse(head);
        p = head;
        // while循环处理每个节点的逻辑
        while(p != null){
            if(p.val >= 10){
                p.val -= 10;
                if(p.next != null){
                    p.next.val += 1;
                }else{
                    p.next = new ListNode(1, null);
                }
            }
            p = p.next;
        }
        // 整个链表处理完了，再将链表倒置，数字高位在链表前面
        head = reverse(head);
        return head;
        
    }
    private ListNode reverse(ListNode head) {
        // 新链表的哨兵节点
        ListNode dummy = new ListNode(10086, null);
        // 头插法
        while(head != null){
            ListNode p = head.next;
            head.next = dummy.next;
            dummy.next = head;
            head = p;
        }
        return dummy.next;
    }
}
相关推荐
itoshi rin11 分钟前
简单题21 - 合并两个有序链表（Java）20240917
java·数据结构·链表
程序猿练习生23 分钟前
C++速通LeetCode简单第16题-买卖股票的最佳时机
开发语言·c++·leetcode
Chase-Hart24 分钟前
【每日一题】LeetCode 1184.公交站间的距离问题（数组）
java·算法·leetcode·eclipse·intellij-idea
Antonio9151 小时前
【高级数据结构】树状数组
数据结构·c++·算法
大晴的上分之旅2 小时前
树和二叉树基本术语、性质
数据结构·算法·二叉树
Chase-Hart2 小时前
【每日一题】LeetCode 815.公交路线（广度优先搜索、数组、哈希表）
数据结构·算法·leetcode·散列表·宽度优先
Am心若依旧4092 小时前
[C++进阶[六]]list的相关接口模拟实现
开发语言·数据结构·c++·算法·list
人才程序员3 小时前
CSP-J 算法基础 广度优先搜索BFS
数据结构·c++·算法·深度优先·宽度优先·比赛·noi
GZK.3 小时前
【Leetcode】70. 爬楼梯
算法·leetcode·动态规划
.普通人5 小时前
c语言--力扣简单题目（链表的中间节点）讲解
c语言·leetcode·链表
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04CANoe Trace窗口过滤栏消失的几种解决方法（附上最终解决方案）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CCF-CSP认证考试 202406-3 文本分词 100分题解