Leetcode 使用栈进行链表翻转的简单理解

Leetcode92.反转链表Ⅱ

题目

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

前言

对于链表翻转，可以很自然的想到使用栈来模拟链表翻转的过程

示例解题思路

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

我们的思路为链表分割为三个部分：
头部(1->null)
中部(2->3->4->null)
尾部(5->null)
设置leftNode、middleNode、rightNode三个辅助变量

给middleNode设置头节点（-510）可以避免一些讨论,
压入栈中的元素依次为(忽略末尾指向的null):

• 2->3->4->5
• 3->4->5
• 4->5

这里pMiddleNode为指向MiddleNode的"指针"

1. 首先pMiddleNode指向的节点为-510，连接出栈元素后，middleNode现在为-510 -> 4 -> 5，此时让pMiddleNode指向的节点为4
2. 接着连接出栈元素，middleNode现在为-510 -> 4 -> 3 -> 4 -> 5，pMiddleNode指向的节点变为3
3. 连接完最后一个出栈后，middleNode为-510 -> 4 -> 3 -> 2 -> 3 -> 4 -> 5，pMiddleNode指向的节点变为2
4. 此时我们只需要让pMiddleNode指向rightNode，-510 -> 4 -> 3 -> 2 -> 5
5. 再让leftNode指向pMiddleNode.next， 1 -> 4 -> 3 -> 2 -> 5

代码(Java)

public ListNode reverseBetween(ListNode head, int left, int right) {
        int count = 1;
        Stack<ListNode> stack = new Stack<>();
        ListNode middleNode = new ListNode(-510), leftNode = null, rightNode = null, res = head;
        while (head != null) {
            if (count == left - 1) {
                leftNode = head;
            } else if (count >= left && count <= right) {
                stack.push(head);
            } else if (count == right + 1) {
                rightNode = head;
            }
            head = head.next;
            count++;
        }
        ListNode pMiddleNode = middleNode;
        while (stack.size() != 0) {
            pMiddleNode.next = stack.pop();
            pMiddleNode = pMiddleNode.next;
        }
        pMiddleNode.next = rightNode;
        if (leftNode == null)
            return middleNode.next;

        leftNode.next = middleNode.next;
        return res;
    }

Leetcode25.K个一组翻转链表

题目

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

前言

类似于上一题的思路，使用栈来模拟翻转

示例解题思路

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]

1. 依次将每个节点压入栈中
2. 如果栈的容量达到k个，进行出栈。
3. 如果栈不为空，则代表有剩余节点。此时只需要指向栈底的节点

代码(Java)

public ListNode reverseKGroup(ListNode head, int k) {        
        Stack<ListNode> stack = new Stack<>();
        ListNode res = new ListNode(-1), pRes = res;
        while (head != null) {
            stack.push(head);
            head = head.next;
            if (stack.size() == k) {
                while (stack.size() != 0) {
                    pRes.next = stack.pop();
                    pRes = pRes.next;
                }
            }   
        }
        if (!stack.isEmpty()) {     
            pRes.next = stack.firstElement();
        } else {
            pRes.next = null;
        }
        return res.next;
    }