链表反转的拓展问题

最新推荐文章于 2025-12-08 12:04:40 发布

原创最新推荐文章于 2025-12-08 12:04:40 发布 · 105 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #python #数据结构 #java #算法

1. 指定区间反转

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。

示例 1：
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

1.1 头插法

在需要反转的区间里, 每遍历到一个节点, 让这个节点来到区间起始的位置。

在这里插入图片描述

/**
 * 头插法
 *
 * @param head
 * @param left
 * @param right
 * @return
 */
public static ListNode reverseBetween2(ListNode head, int left, int right) {
    // 设置 dummyNode 是这一类问题的一般做法
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
    // 找到反转区间的起始位置
    ListNode prev = dummyNode;
    for (int i = 0; i < left - 1; i++) {
        prev = prev.next;
    }
    // 遍历反转区间节点
    ListNode cur = prev.next;
    ListNode next;
    for (int i = 0; i < right - left; i++) {
        next = cur.next;
        cur.next = next.next;
        next.next = prev.next;
        prev.next = next;
    }
    return dummyNode.next;
}

1.2 穿针引线法

在这里插入图片描述

第一步: 将待反转区域反转

第二步: 将前驱节点pre的next指针指向反转后的链表头节点, 将反转以后的链表尾节点的next指针指向后继节点succ

/**
 * 穿针引线法
 *
 * @param head
 * @param left
 * @param right
 * @return
 */
public static ListNode reverseBetween(ListNode head, int left, int right) {
    // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
    // 前驱节点
    ListNode pre = dummyNode;
    // 找到待反转区域的前一个节点
    for (int i = 0; i < left - 1; i++) {
        pre = pre.next;
    }
    // 找到待反转区域的结束节点
    ListNode rightNode = pre;
    for (int i = 0; i < right - left + 1; i++) {
        rightNode = rightNode.next;
    }
    // 后驱节点
    ListNode succ = rightNode.next;
    
    // 截取链表
    ListNode leftNode = pre.next;
    rightNode.next = null;
    ListNode prev = null;
    // 反转待反转区域
    ListNode curr = leftNode;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    pre.next = rightNode;
    leftNode.next = succ;
    return dummyNode.next;
}

2. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

解决思路:

假设当前节点为node1, 下一个节点为node2。将node1的next指针指向node2.next, node2的next指针指向node1, 遍历链表循环操作。

在这里插入图片描述

代码实现:

 /**
 * 直接根据两个指针的情况来设置
  * @param head
  * @return
  */
 public static  ListNode swapPairs(ListNode head) {
     ListNode dummyHead = new ListNode(0);
     dummyHead.next = head;
     ListNode curr = dummyHead;
     while (curr.next != null && curr.next.next != null) {
         ListNode node1 = curr.next;
         ListNode node2 = curr.next.next;
         node1.next = node2.next;
         node2.next = node1;
         curr.next = node2;
         curr = node1;
     }
     return dummyHead.next;
 }

3. 链表加1

用一个非空单链表来表示一个非负整数，然后将这个整数加一。你可以假设这个整数除了 0 本身，没有任何前导的 0。这个整数的各个数位按照高位在链表头部、低位在链表尾部的顺序排列。

示例:
输入: [1,2,3]
输出: [1,2,4]

解决思路:

加法计算是从低位开始, 而链表是从高位开始的, 因此首先需要将链表进行反转, 这里使用栈实现。遍历链表, 并将节点依次压入栈中, 然后从栈中依次弹出元素进行计算, 需要特别处理的是进位的情况。

在这里插入图片描述

代码实现:

/**
* 链表加1
 * @param head
 * @return
 */
public static ListNode plusOne(ListNode head) {
    Stack<ListNode> stack = new Stack<>();
    while (head != null) {
        stack.push(head);
        head = head.next;
    }
    // 记录是否进位
    int carry = 0;
    // 加的数字
    int addNumber = 1;
    // 用来保留指向出栈元素的指针
    ListNode dummyNode = new ListNode(0);
    while (!stack.empty() || carry > 0) {
        int digit = stack.empty() ? 0 : stack.pop().val;
        int sum = digit + addNumber + carry;
        carry = sum >= 10 ? 1 : 0;
        sum = sum >= 10 ? sum - 10 : sum;
        ListNode curr = new ListNode(sum);
        curr.next = dummyNode.next;
        dummyNode.next = curr;
        addNumber = 0;
    }
    return dummyNode.next;
}

使用链表反转实现

/**
* 链表反转实现
 * @param head
 * @return
 */
public static ListNode plusOneByReverse(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;
    while (curr != null) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    curr = prev;
    // 记录是否进位
    int carry = 0;
    // 加的数字
    int addNumber = 1;
    // 用来保留指向出栈元素的指针
    ListNode dummyNode = new ListNode(0);
    while (curr != null || carry > 0) {
        int digit = curr == null ? 0 : curr.val;
        int sum = digit + addNumber + carry;
        carry = sum >= 10 ? 1 : 0;
        sum = sum >= 10 ? sum - 10 : sum;
        ListNode newNode = new ListNode(sum);
        newNode.next = dummyNode.next;
        dummyNode.next = newNode;
        addNumber = 0;
        // 当原链表所有节点都进位时, 会出现 curr = null 的情况
        if (curr != null) {
            curr = curr.next;
        }
    }
    return dummyNode.next;
}

4. 链表加法

给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。你可以假设除了数字 0 之外，这两个数字都不会以零开头。

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

在这里插入图片描述

解题思路:

将两个链表分别压入两个栈中, 然后再一起出栈, 将两个结果分别计算。之后对计算结果取模, 模数保存到新的链表中, 进位保存到下一轮。

代码实现:

/**
 * 通过栈来实现
 *
 * @param head1
 * @param head2
 * @return
 */
public static ListNode addInListByStack(ListNode head1, ListNode head2) {
    Stack<ListNode> stack1 = new Stack<>();
    Stack<ListNode> stack2 = new Stack<>();
    while (head1 != null) {
        stack1.push(head1);
        head1 = head1.next;
    }
    while (head2 != null) {
        stack2.push(head2);
        head2 = head2.next;
    }
    int carry = 0;
    ListNode dummyNode = new ListNode(-1);
    while (!stack1.empty() || !stack2.empty() || carry > 0) {
        int digit1 = stack1.empty() ? 0 : stack1.pop().val;
        int digit2 = stack2.empty() ? 0 : stack2.pop().val;
        int sum = digit1 + digit2 + carry;
        carry = sum >= 10 ? 1 : 0;
        sum %= 10;
        ListNode curr = new ListNode(sum);
        curr.next = dummyNode.next;
        dummyNode.next = curr;
    }
    return dummyNode.next;
}

使用链表反转实现:

/**
 * 通过链表反转来实现
 *
 * @param head1
 * @param head2
 * @return
 */
public static ListNode addInListByReverse(ListNode head1, ListNode head2) {
    head1 = reverse(head1);
    head2 = reverse(head2);
    ListNode curr1 = head1;
    ListNode curr2 = head2;
    ListNode dummyNode = new ListNode(-1);
    int carry = 0;
    while (curr1 != null || curr2 != null || carry > 0) {
        int digit1 = curr1 == null ? 0 : curr1.val;
        int digit2 = curr2 == null ? 0 : curr2.val;
        int sum = digit1 + digit2 + carry;
        carry = sum >= 10 ? 1 : 0;
        sum %= 10;
        ListNode curr = new ListNode(sum);
        curr.next = dummyNode.next;
        dummyNode.next = curr;
        if (curr1 != null) {
            curr1 = curr1.next;
        }
        if (curr2 != null) {
            curr2 = curr2.next;
        }
    }
    return dummyNode.next;
}