算法学习笔记——链表反转拓展问题

链表反转有几道很常见的拓展问题,这些都是面试的高频问题,这一关,我们来集中研究一下。

1. 指定区间反转

92. 反转链表 II - 力扣(LeetCode)

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

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

img

这里的处理方式也有多种,甚至给个名字都有点困难,干脆就分别叫穿针引线法和头插法吧。穿针引线本质上就是不带有节点的方式来实现反转,而头插法本质上就是带头结点的反转。

1.1 头插法

方法一的缺点是:如果 left 和 right 的区域很大,恰好是链表的头节点和尾节点时,找到 left 和 right 需要遍历一次,反转它们之间的链表还需要遍历一次,虽然总的时间复杂度为 O(N),但遍历了链表 2次,可不可以只遍历一次呢?答案是可以的。我们依然画图进行说明,我们仍然以方法一的序列为例进行说明。

image.png

反转的整体思想是,在需要反转的区间里,每遍历到一个节点,让这个新节点来到反转部分的起始位置。下面的图展示了整个流程。

image.png

这个过程就是前面的带虚拟结点的插入操作,每走一步都要考虑各种指针怎么指,既要将结点摘下来接到对应的位置上,还要保证后续结点能够找到,请读者务必画图看一看,想一想到底该怎么调整。代码如下:

public static ListNode reverseBetween1(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 cur = pre.next;
    ListNode next;
    for (int i = 0; i < right - left; i++) {
        next = cur.next;
        cur.next = next.next;
        next.next = pre.next;
        pre.next = next;
    }
    return dummyNode.next;
}

pre指针走到指定区间的前面后固定不变,cur指针指定一个固定的结点在指定区间移动

头插法

1.2 穿针引线法

这种方式能够复用我们前面讲的链表反转方法,但是实现难度仍然比较高一些。
我们以反转下图中蓝色区域的链表反转为例:

image.png

我们可以这么做:先确定好需要反转的部分,也就是下图的 left 到 right 之间,然后再将三段链表拼接起来。这种方式类似裁缝一样,找准位置减下来,再缝回去。这样问题就变成了如何标记下图四个位置,以及如何反转left到right之间的链表。

image.png

算法步骤:

  • 第 1 步:先将待反转的区域反转;
  • 第 2 步:把 pre 的 next 指针指向反转以后的链表头节点,把反转以后的链表的尾节点的 next 指针指向 succ。

image.png

编码细节我们直接看下方代码。思路想明白以后,编码不是一件很难的事情。这里要提醒大家的是,链接什么时候切断,什么时候补上去,先后顺序一定要想清楚,如果想不清楚,可以在纸上模拟,思路清晰。

public static ListNode reverseBetween2(ListNode head, int left, int right) {
    // 因为头结点有可能发生变化,使用虚拟结点可以避免复杂的分类
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;

    ListNode pre = dummyNode;
    // 第 1 步:从虚拟头节点走 left - 1 步,来到 left 节点的前一个节点
    for (int i = 0; i < left - 1; i++) {
        pre = pre.next;
    }
    // 第 2 步:从 pre 再走 right - left + 1 步,来到 right 节点
    ListNode rightNode = pre;
    for (int i = 0; i < right - left + 1; i++) {
        rightNode = rightNode.next;
    }
    // 第 3 步:切断出一个子链表(截取链表)
    ListNode leftNode = pre.next;
    ListNode succ = rightNode.next;

    // 注意: 切断链表
    rightNode.next = null;

    // 第 4 步:同第 206 题,反转链表的子区间
    reverseList(leftNode);

    // 第 5 步:接回到原来的链表中
    pre.next = rightNode;
    leftNode.next = succ;
    return dummyNode.next;
}

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

这是一道非常重要的问题,读者务必理解清楚。

24. 两两交换链表中的节点 - 力扣(LeetCode)

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

image.png

如果要解决该问题,将上面小节的K换成2不就是这个题吗?道理确实如此,但是如果K为2的时候,可以不需要像K个一样需要先遍历找到区间的两端,而是直接取前后两个就行了,因此基于相邻结点的特性重新设计和实现就行,不需要上面这么复杂的操作。
如果原始顺序是 dummy -> node1 -> node2,交换后面两个节点关系要变成 dummy -> node2 -> node1,事实上我们只要多执行一次next就可以拿到后面的元素,也就是类似node2 = temp.next.next这样的操作。
两两交换链表中的节点之后,新的链表的头节点是 dummyHead.next,返回新的链表的头节点即可。指针的调整可以参考如下图示:
完整代码是:

public static ListNode swapPairs(ListNode head) {
    ListNode dummyHead = new ListNode(0);
    dummyHead.next = head;
    ListNode cur = dummyHead;
    while (cur.next != null && cur.next.next != null) {
        ListNode node1 = cur.next;
        ListNode node2 = cur.next.next;
        cur.next = node2;
        node1.next = node2.next;
        node2.next = node1;
        cur = node1;
    }
    return dummyHead.next;
}

3. 单链表加1

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

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

image.png

public static ListNode plusOne(ListNode head) {
    Stack<Integer> st = new Stack();
    while (head != null) {
        st.push(head.val);
        head = head.next;
    }
    int carry = 0;
    ListNode dummy = new ListNode(0);
    int adder = 1;
    while (!st.empty() || carry > 0) {
        int digit = st.empty() ? 0 : st.pop();
        int sum = digit + adder + carry;
        carry = sum >= 10 ? 1 : 0;
        sum = sum >= 10 ? sum - 10 : sum;
        ListNode cur = new ListNode(sum);
        cur.next = dummy.next;
        dummy.next = cur;
        adder = 0;
    }
    return dummy.next;
}

在这里插入图片描述

上面代码,我们简单解释一下,carry的功能是记录进位的,相对好理解 。
那这里的adder是做什么的很多人会感到困惑,这个主要表示就是需要加的数1,也就是为了满足单链表加1的功能,那这里能否直接使用1 ,而不再定义变量呢?也就是将上面的while循环改成这样子:

while (!st.empty() || carry > 0) {
    int digit = st.empty() ? 0 : st.pop();
    int sum = digit + 1 + carry;
    carry = sum >= 10 ? 1 : 0;
    sum = sum >= 10 ? sum - 10 : sum;
    ListNode cur = new ListNode(sum);
    cur.next = dummy.next;
    dummy.next = cur;
}

很遗憾,这样不行的,否则的话 ,会将我们每个位置都加1,例如,如果原始单链表是{7,8}这里就会将其变成{8,9},而不是我们要的{7,9},导致这样的原因是循环处理链表每个结点元素的时候sum = digit + 1 + carry这一行会将每个位置都多加了一个1,所以我们要使用变量adder,只有第一次是加了1,之后该变量变成0了,就不会影响我们后续计算。

基于链表反转实现 如果这里不使用栈,使用链表反转来实现该怎么做呢?很显然,我们先将原始链表反转,这方面完成加1和进位等处理,完成之后再次反转。

4. 链表加法

445. 两数相加 II - 力扣(LeetCode)

相加相链表是基于链表构造的一种特殊题,反转只是其中的一部分。这个题还存在进位等的问题,因此看似简单,但是手写成功并不容易。
LeetCode445题,给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。你可以假设除了数字 0 之外,这两个数字都不会以零开头。示例:

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

img

这个题目的难点在于存放是从最高位向最低位开始的,但是因为低位会产生进位的问题,计算的时候必须从最低位开始。所以我们必须想办法将链表节点的元素反转过来。
怎么反转呢?栈和链表反转都可以,两种方式我们都看一下。

(1) 使用栈实现
思路是先将两个链表的元素分别压栈,然后再一起出栈,将两个结果分别计算。之后对计算结果取模,模数保存到新的链表中,进位保存到下一轮。完成之后再进行一次反转就行了。
我们知道在链表插入有头插法和尾插法两种。头插法就是每次都将新的结点插入到head之前。而尾插法就是将新结点都插入到链表的表尾。两者的区别是尾插法的顺序与原始链表是一致的,而头插法与原始链表是逆序的,所以上面最后一步如果不想进行反转,可以将新结点以头插法。

public static ListNode addInListByStack(ListNode head1, ListNode head2) {
    Stack<ListNode> st1 = new Stack<>();
    Stack<ListNode> st2 = new Stack<>();
    while (head1 != null) {
        st1.push(head1);
        head1 = head1.next;
    }
    while (head2 != null) {
        st2.push(head2);
        head2 = head2.next;
    }
    ListNode newHead = new ListNode(-1);
    int carry = 0;
    // 这里设置carry!=0,是因为当st1,st2都遍历完时,如果carry=0,就不需要进入循环了
    while (!st1.empty() || !st2.empty() || carry != 0) {
        ListNode a = new ListNode(0);
        ListNode b = new ListNode(0);
        if (!st1.empty()) {
            a = st1.pop();
        }
        if (!st2.empty()) {
            b = st2.pop();
        }
        // 每次的和应该是对应位相加再加上进位
        int get_sum = a.val + b.val + carry;
        // 对累加的结果取余
        int ans = get_sum % 10;
        // 如果大于0,就进位
        carry = get_sum / 10;
        ListNode cur = new ListNode(ans);
        cur.next = newHead.next;
        // 每次把最新得到的结点更新到newHead.next中
        newHead.next = cur;
    }
    return newHead.next;
}

在这里插入图片描述

(2)使用链表反转实现
如果使用链表反转,先将两个链表分别反转,最后计算完之后再将结果反转,一共有三次反转操作,所以必然将反转抽取出一个方法比较好,代码如下:

public static ListNode addInListByReverse(ListNode head1, ListNode head2) {
    head1 = reverse(head1);
    head2 = reverse(head2);
    ListNode head = new ListNode(-1);
    ListNode cur = head;
    int carry = 0;
    while (head1 != null || head2 != null) {
        int val = carry;
        if (head1 != null) {
            val += head1.val;
            head1 = head1.next;
        }
        if (head2 != null) {
            val += head2.val;
            head2 = head2.next;
        }
        cur.next = new ListNode(val % 10);
        carry = val / 10;
        cur = cur.next;
    }
    if (carry > 0) {
        cur.next = new ListNode(carry);
    }
    return reverse(head.next);
}

在这里插入图片描述

5. 再论链表的回文序列问题

在上一关介绍链表回文串的时候,我们介绍的是基于栈的,相对来说比较好理解,但是除此之外还有可以使用链表反转来进行,而且还可以只反转一半链表,这种方式节省空间。
我们姑且称之为“快慢指针+一半反转”法。
这个实现略有难度,主要是在while循环中pre.next = prepre和prepre = pre两行实现了一边遍历一边将访问过的链表给反转了,所以理解起来有些难度。

public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null) {
            return true;
        }
        ListNode slow = head, fast = head;
        ListNode pre = head, prepre = null;
        while(fast != null && fast.next != null) {
            pre = slow;
            slow = slow.next;
            fast = fast.next.next;
            //将前半部分链表反转
            pre.next = prepre;
            prepre = pre;
        }
        if(fast != null) {
            slow = slow.next;
        }
        while(pre != null && slow != null) {
            if(pre.val != slow.val) {
                return false;
            }
            pre = pre.next;
            slow = slow.next;
        }
        return true;
    }
  1. 首先,如果链表为空或只有一个节点,则认为是回文序列,返回 true。

  2. 使用快慢指针法,初始化两个指针 slow 和 fast,都指向链表的头节点 head。slow 指针每次移动一步,fast 指针每次移动两步。通过快慢指针的移动,找到链表的中间节点。

  3. 在遍历过程中,使用两个额外的节点 pre 和 prepre 来实现链表的反转。pre 节点用于记录 slow 的前一个节点,prepre 节点用于记录 pre 的前一个节点。初始时,pre 和 prepre 都指向 head。
    在这里插入图片描述

  4. 在快慢指针遍历的过程中,每次将 pre 节点指向 prepre,实现链表的反转。最终,当遍历完成时,pre 就指向了链表的前半部分的最后一个节点。

  5. 如果链表的长度为奇数,fast 不为空;如果链表的长度为偶数,fast 为空。根据链表长度的奇偶性,调整 slow 的位置,使其指向后半部分链表的起始节点。
    在这里插入图片描述

  6. 最后,分别遍历前半部分和后半部分链表,比较节点的值是否相同。如果有不相同的节点,则链表不是回文序列,返回 false;如果全部节点都相同,则链表是回文序列,返回 true。
    在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值