链表的删除 203、237、19 链表的遍历 430

最新推荐文章于 2024-10-18 09:00:00 发布

Utgnryk

最新推荐文章于 2024-10-18 09:00:00 发布

阅读量844

点赞数 37

文章标签：链表数据结构 leetcode

本文链接：https://blog.csdn.net/Utgnryk/article/details/141292114

版权

203. 移除链表元素（简单）

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

解法一、递归

见代码

链表的定义具有递归的性质，所以遍历也可以以递归的方式进行

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null){
            return head;
        }
        head.next = removeElements(head.next,val);
        return head.val == val ? head.next:head;
    }
}

解法二、迭代

具体实现方面，由于链表的头节点 head 有可能需要被删除，因此创建哑节点 dummyHead，令 dummyHead.next=head，初始化 temp=dummyHead，然后遍历链表进行删除操作。最终返回 dummyHead.next 即为删除操作后的头节点。

——出自力扣官方题解

通过dummyHead的形式，使所有链表元素都不再是链表首，很聪明便捷的形式

也可以头节点另做考虑，先遍历所有之后的，最后判断头结点是不是，是则删除

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        while (temp.next != null) {
            if (temp.next.val == val) {
                temp.next = temp.next.next;
            } else {
                temp = temp.next;
            }
        }
        return dummyHead.next;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-linked-list-elements/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

237. 删除链表中的节点（中等）

有一个单链表的 head，我们想删除它其中的一个节点 node。

给你一个需要删除的节点 node 。你将 无法访问 第一个节点 head。

链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

给定节点的值不应该存在于链表中。
链表中的节点数应该减少 1。
node 前面的所有值顺序相同。
node 后面的所有值顺序相同。

解法一、复制删除

脑筋急转弯题，把这个节点的值变成下一个节点，删掉下一个节点

class Solution {
    public void deleteNode(ListNode node) {
        ListNode temp = node.next;
        node.val = temp.val;
        node.next = temp.next;
    }
}

19. 删除链表的倒数第 N 个结点（中等）

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

解法一、哈希

一遍扫描分别放入哈希，最后根据总数减n的关系直接取。注意倒数第n个是len-n+1,这里改的是它前一个节点的next，所以取len-n

写完才发现真没人用哈希。。感觉其实是栈的低配版本。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int num = 0;
        HashMap<Integer,ListNode> hash = new HashMap<>();
        ListNode temp = head;
        while(temp != null){
            num++;
            hash.put(num,temp);
            temp = temp.next;
        }
        if(n != num){
            ListNode pre = hash.get(num - n);
            pre.next = pre.next == null ? null : pre.next.next;
        }else{
            head = head.next; 
        }
        return head;
    }
}

解法二、双次遍历

就常规意义的扫两次

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        ListNode ans = dummy.next;
        return ans;
    }

    public int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return length;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/450350/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解法三、栈

pop开始计数弹出倒数

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        Deque<ListNode> stack = new LinkedList<ListNode>();
        ListNode cur = dummy;
        while (cur != null) {
            stack.push(cur);
            cur = cur.next;
        }
        for (int i = 0; i < n; ++i) {
            stack.pop();
        }
        ListNode prev = stack.peek();
        prev.next = prev.next.next;
        ListNode ans = dummy.next;
        return ans;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/450350/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

解法四、双指针

一个指针快，一个指针慢，相距n格。处理逻辑比较复杂，既可以添加dummy，也可以全扫一遍最后判断头是不是

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        ListNode first = head;
        ListNode second = dummy;
        for (int i = 0; i < n; ++i) {
            first = first.next;
        }
        while (first != null) {
            first = first.next;
            second = second.next;
        }
        second.next = second.next.next;
        ListNode ans = dummy.next;
        return ans;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/solutions/450350/shan-chu-lian-biao-de-dao-shu-di-nge-jie-dian-b-61/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

430. 扁平化多级双向链表（中等）

你会得到一个双链表，其中包含的节点有一个下一个指针、一个前一个指针和一个额外的 子指针 。这个子指针可能指向一个单独的双向链表，也包含这些特殊的节点。这些子列表可以有一个或多个自己的子列表，以此类推，以生成如下面的示例所示的 多层数据结构 。

给定链表的头节点 head ，将链表 扁平化 ，以便所有节点都出现在单层双链表中。让 curr 是一个带有子列表的节点。子列表中的节点应该出现在扁平化列表中的 curr 之后和 curr.next 之前。

返回 扁平列表的 head 。列表中的节点必须将其所有子指针设置为 null 。

解法一、栈+递归

每次拼接有不必要的多次扫描

对于每个遍历到的i，如果有子节点，把next进栈，递归并返回子节点的头，然后一路推到尾；如果是这一行最后一个，且栈不为空，则出栈然后拼接。

class Solution {
    static Deque<Node> st = new ArrayDeque<>();
    public static Node flatten(Node head) {
        Node i = head;
        while(i != null){
            if(i.child != null){
                if(i.next != null){
                    st.push(i.next);
                }
                i.next = flatten(i.child);
                i.next.prev = i;
                i.child = null;
                while(i!=null){
                    i = i.next;
                }
            }
            if(i != null && i.next == null && !st.isEmpty()){
                i.next = st.pop();
                i.next.prev = i;
            }
            if(i != null)i = i.next;
        }
        return head;
    }
}

解法二、栈

遇子节点则next入栈，遍历结束子节点后，把栈pop出来拼接。

class Solution {
    public Node flatten(Node head) {
        Node node = head;
        Node prev = null;
        Deque<Node> stack = new ArrayDeque<>();
        while (node != null || !stack.isEmpty()) {
            if (node == null) {
                node = stack.pop();
                node.prev = prev;
                prev.next = node;
            }
            if (node.child != null) {
                if (node.next != null) stack.push(node.next);
                node.child.prev = node;
                node.next = node.child;
                node.child = null;
            }
            prev = node;
            node = node.next;
        }
        return head;
    }
}

解法三、递归（DFS）

见注释。解法一之所以会对末尾进行重复的多次遍历，是因为返回的是头，则另外写一个dfs函数、返回尾即可。

class Solution {
    public Node flatten(Node head) {
        dfs(head);
        return head;
    }

    public Node dfs(Node node) {
        Node cur = node;
        // 记录链表的最后一个节点
        Node last = null;

        while (cur != null) {
            Node next = cur.next;
            //  如果有子节点，那么首先处理子节点
            if (cur.child != null) {
                Node childLast = dfs(cur.child);

                next = cur.next;
                //  将 node 与 child 相连
                cur.next = cur.child;
                cur.child.prev = cur;

                //  如果 next 不为空，就将 last 与 next 相连
                if (next != null) {
                    childLast.next = next;
                    next.prev = childLast;
                }

                // 将 child 置为空
                cur.child = null;
                last = childLast;
            } else {
                last = cur;
            }
            cur = next;
        }
        return last;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/flatten-a-multilevel-doubly-linked-list/solutions/1013884/bian-ping-hua-duo-ji-shuang-xiang-lian-b-383h/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。