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

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

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

输入: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;
    }
}

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

你可能感兴趣的:(算法,链表,数据结构)