算法每日一题：从列表中移除节点 | 链表与栈

大家好，我是星恒
今天的题目是一道比较经典的链表题目，他涉及到链表的遍历，链表的创建，处理链表的常用方法，以及常用方法中使用栈的一系列常用技巧
这道题本身不难，但是如果学会处理它，绝对会收获满满！

题目:leetcode 2487
给你一个链表的头节点 head 。
移除每个右侧有一个更大数值的节点。
返回修改后链表的头节点_ head _。
示例：
示例 1：

输入：head = [5,2,13,3,8]
输出：[13,8]
解释：需要移除的节点是 5 ，2 和 3 。
- 节点 13 在节点 5 右侧。
- 节点 13 在节点 2 右侧。
- 节点 8 在节点 3 右侧。

示例 2：

输入：head = [1,1,1,1]
输出：[1,1,1,1]
解释：每个节点的值都是 1 ，所以没有需要移除的节点。

提示：

• 给定列表中的节点数目在范围 [1, 105] 内
• 1 <= Node.val <= 105

分析：
本题我们使用栈的方法来解决，如果大家想了解其他方法，我在下面附了代码

在处理链表时，栈是一种非常常用的技巧，因为处理链表的一个难点，就是链表不容易从后往前访问，而栈恰好具有这种特征（出栈时，后面的先出），所以这不就一拍即合嘛！

这道题也不例外，我们使用栈将链表节点存进来，然后依次出栈，当遇到比结果链表中头结点大的值时，就加入结果链表，更新结果链表的头节点

这道题还有一点不太能想出来（至少我刚开始没想到）；我刚开始想的是将链表遍历一遍，然后将比最后一个元素小的值都剔除一遍，然后再遍历剔除后的链表，剔除比倒数第2个值小的值，依次类推，直到剔除到头节点。
但是就没想到可以边加边更新比较的那个值！也就是没有找到第一大值和第二大值的关系！

题解：
方法一：（官方）栈

class Solution {
    public ListNode removeNodes(ListNode head) {
        Deque<ListNode> stack = new ArrayDeque<ListNode>();
        for (; head != null; head = head.next) {
            stack.push(head);
        }
        for (; !stack.isEmpty(); stack.pop()) {
            if (head == null || stack.peek().val >= head.val) {
                stack.peek().next = head;
                head = stack.peek();
            }
        }
        return head;
    }
}

官方的题解很简洁

• 将head指针利用到了极致：存栈时，最后返回值时
• 将整个结点存入栈的思想也很舒服
• 链表的for循环，学废了吗：for (; head != null; head = head.next)
• stack.isEmpty()，通常用这个来遍历栈（如果使用stack.size，stack.size是会变的，除非把他声明为变量）

我的题解：

/**
 * 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 removeNodes(ListNode head) {
        if (head == null) {
            return new ListNode();
        }

        Deque<Integer> stack = new ArrayDeque<>();

        while(head != null) {
            stack.push(head.val);
            head = head.next;
        }
        
        ListNode res = new ListNode(stack.pop());
        while(!stack.isEmpty()) {
            int top = stack.pop();
            if (top >= res.val) {
                res = new ListNode(top, res);
            }
        }

        return res;
    }
}

方法二：递归

class Solution {
    public ListNode removeNodes(ListNode head) {
        if (head == null) {
            return null;
        }
        head.next = removeNodes(head.next);
        if (head.next != null && head.val < head.next.val) {
            return head.next;
        } else {
            return head;
        }
    }
}

方法三：反转链表

class Solution {
    public ListNode removeNodes(ListNode head) {
        head = reverse(head);
        for (ListNode p = head; p.next != null; ) {
            if (p.val > p.next.val) {
                p.next = p.next.next;
            } else {
                p = p.next;
            }
        }
        return reverse(head);
    }

    public ListNode reverse(ListNode head) {
        ListNode dummy = new ListNode();
        while (head != null) {
            ListNode p = head;
            head = head.next;
            p.next = dummy.next;
            dummy.next = p;
        }
        return dummy.next;
    }
}

如果大家有什么思考和问题，可以在评论区讨论，也可以私信我，很乐意为大家效劳。
好啦，今天的每日一题到这里就结束了，如果大家觉得有用，可以可以给我一个小小的赞呢，我们下期再见！