【学习笔记】leetcode每日五题（9.28）

每日五题（9.28）

1.重排链表

链接：https://leetcode.cn/problems/LGjMqU/)

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln-1 → Ln
请将其重新排列后变为：

L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

（即第一个指向最后一个，第二个指向倒数第二个）

输入: head = [1,2,3,4]
输出: [1,4,2,3]

思路解析；

线性表，我们将这些节点有序存储进链表ArrayList中，再从其中按照我们的需要取出来即可，指定两个指针，一个从头开始，一个从尾开始，头指针每次后移，尾指针每次前移

class Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        List<ListNode> list = new ArrayList<ListNode>();
        ListNode node = head;
        while (node != null) {
            list.add(node);
            node = node.next;
        }
        int i = 0, j = list.size() - 1;
        while (i < j) {
            list.get(i).next = list.get(j);
            i++;
            if (i == j) {
                break;
            }
            list.get(j).next = list.get(i);
            j--;
        }
        list.get(i).next = null;
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/LGjMqU/solution/zhong-pai-lian-biao-by-leetcode-solution-wm25/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2.回文链表

链接：https://leetcode.cn/problems/aMhZSa/

给定一个链表的 头节点 head **，**请判断其是否为回文链表。

如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。

输入: head = [1,2,3,3,2,1]
输出: true

思路解析：

有了上题的经验，我们同样可以建立一个线性表ArrayList，然后存储链表进去，最后首尾访问比对，得出结果。在这里，官方使用了数组对节点的值进行了存储，再使用双指针进行比较

class Solution {
    public boolean isPalindrome(ListNode head) {
        List<Integer> vals = new ArrayList<Integer>();

        // 将链表的值复制到数组中
        ListNode currentNode = head;
        while (currentNode != null) {
            vals.add(currentNode.val);
            currentNode = currentNode.next;
        }

        // 使用双指针判断是否回文
        int front = 0;
        int back = vals.size() - 1;
        while (front < back) {
            if (!vals.get(front).equals(vals.get(back))) {
                return false;
            }
            front++;
            back--;
        }
        return true;
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/aMhZSa/solution/hui-wen-lian-biao-by-leetcode-solution-3q3r/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3.排序的循环链表

链接：https://leetcode.cn/problems/4ueAj6/

给定循环单调非递减列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。

给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。

如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。

如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。

输入：head = [3,4,1], insertVal = 2
输出：[3,4,1,2]
解释：在上图中，有一个包含三个元素的循环有序列表，你获得值为 3 的节点的指针，我们需要向表中插入元素 2 。新插入的节点应该在 1 和 3 之间，插入之后，整个列表如上图所示，最后返回节点 3 。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LHmmdLme-1664381252732)(C:\Users\YZY\AppData\Roaming\Typora\typora-user-images\image-20220928232354752.png)]

思路分析：

我们对原链表一直遍历，使用cur和next来保存当前和下一个节点

现有三种情况需要插入新节点node：

• cur.val<=node.val<=next.val，此时我们将新节点插入cur和next之间即可
• cur>next.val and node.val>cur.val,此时node.val最大，而cur为链表末尾,next为开头,所以还是插在他们俩中间
• cur>next.val and node.val<next.val,此时表示node.val比所有人都小，而cur为链表末尾，next为开头，此时node还是插在他们中间，node作为新的头

class Solution {
    public Node insert(Node head, int insertVal) {
        Node node = new Node(insertVal);
        if (head == null) {
            node.next = node;
            return node;
        }
        if (head.next == head) {
            head.next = node;
            node.next = head;
            return head;
        }
        Node curr = head, next = head.next;
        while (next != head) {
            if (insertVal >= curr.val && insertVal <= next.val) {
                break;
            }
            if (curr.val > next.val) {
                if (insertVal > curr.val || insertVal < next.val) {
                    break;
                }
            }
            curr = curr.next;
            next = next.next;
        }
        curr.next = node;
        node.next = next;
        return head;
    }
}

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/4ueAj6/solution/pai-xu-de-xun-huan-lian-biao-by-leetcode-f566/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

4.展平多级双向链表

链接：https://leetcode.cn/problems/Qv1Da2/)

多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。

给定位于列表第一级的头节点，请扁平化列表，即将这样的多级双向链表展平成普通的双向链表，使所有结点出现在单级双链表中。

总结：每个节点有prev，next，child（有些不存在）3个指向，将多级的扁平化为普通双向链表，规则就是碰到child子项的优先处理子项

输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
输出：[1,2,3,7,8,11,12,9,10,4,5,6]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lXs6jXnd-1664381252733)(C:\Users\YZY\AppData\Roaming\Typora\typora-user-images\image-20220928233834791.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0x2VgzdD-1664381252734)(C:\Users\YZY\AppData\Roaming\Typora\typora-user-images\image-20220928233858638.png)]

思路解析：

深度优先搜索

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;
            //  如果有子节点，那么首先处理子节点
            //如果没有子节点，我们使得last为cur，因为最后返回的时last，所以需要更新
            //如果有子节点，先用next保存cur的下一个，再让子节点成为下一个，让cur成为子节点的上一个，并遍历得到子链的最后一个节点，
            if (cur.child != null) {
                //有递归的思想，如果cur.child链中还有child存在，我们依旧可以处理掉
                Node childLast = dfs(cur.child);

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

                //  如果 next 不为空，就将 last 与 next 相连
                //一直遍历，直到next为空停止，next已经为空的话，next.prev就是最后一个了
                if (next != null) {
                    childLast.next = next;
                    next.prev = childLast;
                }

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

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/Qv1Da2/solution/zhan-ping-duo-ji-shuang-xiang-lian-biao-x5ugr/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。