【剑指 Offer】第 2 天

Offer 驾到，掘友接招！我正在参与2022春招系列活动-刷题打卡任务，点击查看活动详情。

一、前言

刷题啊！！！

开始刷 “剑指 Offer” 31天。刷完时间：2022.3.6 ~ 2022.3.20。

链表（Linked list）：是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

二、题目

题目：

1. 从尾到头打印链表
2. 反转链表
3. 复杂链表的复制

（1）剑指 Offer 06. 从尾到头打印链表

题目描述

---

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

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

限制：0 <= 链表长度 <= 10000

题解

---

题意：倒输数组里的元素

利用辅助栈的特性：先进后出：

1. 先将列表中的元素放入栈中
2. 再将栈中元素输出

class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode p = head;
        Stack<Integer> stack = new Stack<>();
        while (p != null) {
            stack.push(p.val);
            p = p.next;
        }
        int [] result = new int[stack.size()];
        int i = 0;
        while (!stack.isEmpty()) {
            result[i ++ ] = stack.pop();
        }
        return result;
    }
}

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

（2）剑指 Offer 24. 反转链表

题目描述

---

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：0 <= 节点个数 <= 5000

题解

---

利用临时节点、前一个节点：

• 临时节点：存储当前节点的下一个节点
• 前一个节点：存储前一个节点

AC 代码如下：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null, p = head;
        while (p != null) {
            ListNode tmp = p.next;
            p.next = pre;
            pre = p;
            p = tmp;
        }
        return pre;
    }
}

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

（3）剑指 Offer 35. 复杂链表的复制

题目描述

---

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

示例 1：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

示例 4：

输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。

提示：

• -10000 <= Node.val <= 10000
• Node.random 为空（null）或指向链表中的节点。
• 节点数目不超过 1000 。

题解

---

用一个 Map 来存储各节点：

1. 遍历一次：先创建各节点
2. 遍历一次：再构建各个节点关系

AC 代码如下：

class Solution {
    Map<Node, Node> map = new HashMap<>();
    public Node copyRandomList(Node head) {
        Node p = head;
        
        while (p != null) {
            Node node = new Node(p.val);
            map.put(p, node);
            p = p.next;
        }

        p = head;
        while (p != null) {
            Node temp = map.get(p);

            Node next = map.get(p.next);

            Node random = map.get(p.random);

            temp.next = next;
            temp.random = random;

            p = p.next;
        }
        return map.get(head);
    }
}

class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}