栈题目：设计浏览器历史记录

题目

标题和出处

标题：设计浏览器历史记录

出处：1472. 设计浏览器历史记录

难度

6 级

题目描述

要求

你有一个只支持单个标签页的浏览器，最开始你浏览的网页是 $\text{homepage}$，你可以访问其他的网站 $\text{url}$，也可以在浏览历史中后退 $\text{steps}$ 步或前进 $\text{steps}$ 步。

请你实现 $\text{BrowserHistory}$ 类：

• $\text{BrowserHistory(string homepage)}$ 用 $\text{homepage}$ 初始化浏览器类。
• $\text{void visit(string url)}$ 从当前页跳转访问 $\text{url}$ 对应的页面。执行此操作会把浏览历史前进的记录全部删除。
• $\text{string back(int steps)}$ 在浏览历史中后退 $\text{steps}$ 步。如果你只能在浏览历史中后退至多 $\text{x}$ 步且 $\text{steps > x}$，那么你只后退 $\text{x}$ 步。请返回后退至多 $\text{steps}$ 步以后的 $\text{url}$。
• $\text{string forward(int steps)}$ 在浏览历史中前进 $\text{steps}$ 步。如果你只能在浏览历史中前进至多 $\text{x}$ 步且 $\text{steps > x}$，那么你只前进 $\text{x}$ 步。请返回前进至多 $\text{steps}$ 步以后的 $\text{url}$。

示例

示例 1：

输入：
$\text{["BrowserHistory","visit","visit","visit","back","back","forward","visit","forward","back","back"]}$
$\text{[["leetcode.com"],["google.com"],["facebook.com"],["youtube.com"],[1],[1],[1],["linkedin.com"],[2],[2],[7]]}$
输出：
$\text{[null,null,null,null,"facebook.com","google.com","facebook.com",null,"linkedin.com","google.com","leetcode.com"]}$
解释：
$\text{BrowserHistory browserHistory = new BrowserHistory("leetcode.com");}$
$\text{browserHistory.visit("google.com");}$ // 你原本在浏览 $\text{"leetcode.com"}$。访问 $\text{"google.com"}$
$\text{browserHistory.visit("facebook.com");}$ // 你原本在浏览 $\text{"google.com"}$。访问 $\text{"facebook.com"}$
$\text{browserHistory.visit("youtube.com");}$ // 你原本在浏览 $\text{"facebook.com"}$。访问 $\text{"youtube.com"}$
$\text{browserHistory.back(1);}$ // 你原本在浏览 $\text{"youtube.com"}$，后退到 $\text{"facebook.com"}$ 并返回 $\text{"facebook.com"}$
$\text{browserHistory.back(1);}$ // 你原本在浏览 $\text{"facebook.com"}$，后退到 $\text{"google.com"}$ 并返回 $\text{"google.com"}$
$\text{browserHistory.forward(1);}$ // 你原本在浏览 $\text{"google.com"}$，前进到 $\text{"facebook.com"}$ 并返回 $\text{"facebook.com"}$
$\text{browserHistory.visit("linkedin.com");}$ // 你原本在浏览 $\text{"facebook.com"}$。访问 $\text{"linkedin.com"}$
$\text{browserHistory.forward(2);}$ // 你原本在浏览 $\text{"linkedin.com"}$，你无法前进任何步数。
$\text{browserHistory.back(2);}$ // 你原本在浏览 $\text{"linkedin.com"}$，后退两步依次先到 $\text{"facebook.com"}$，然后到 $\text{"google.com"}$，并返回 $\text{"google.com"}$
$\text{browserHistory.back(7);}$ // 你原本在浏览 $\text{"google.com"}$，你只能后退一步到 $\text{"leetcode.com"}$，并返回 $\text{"leetcode.com"}$

数据范围

• $\text{1}\le \text{homepage.length}\le \text{20}$
• $\text{1}\le \text{url.length}\le \text{20}$
• $\text{1}\le \text{steps}\le \text{100}$
• $\text{homepage}$ 和 $\text{url}$ 都只包含 $\text{‘.’}$ 或者小写英语字母
• 最多调用 $\text{5000}$ 次 $\text{visit}$、$\text{back}$ 和 $\text{forward}$

解法一

思路和算法

由于浏览器历史记录需要存储相邻的页面记录，因此可以使用链表实现。由于需要同时支持后退和前进操作，因此使用双向链表。

双向链表中的每个结点包含 $\text{url}$ 的信息，表示该结点对应的页面，以及更早的相邻结点 $\text{prev}$ 和更新的相邻结点 $\text{next}$。

实现中需要记录当前访问的页面的结点 $\text{curr}$，所有的操作都是基于 $\text{curr}$。

初始化时，用 $\text{homepage}$ 创建一个结点，此时双向链表中只有一个结点，$\text{curr}$ 指向唯一的结点。

对于访问操作，创建一个页面为 $\text{url}$ 的结点 $\text{node}$，然后令 $\text{curr}.\text{next}$ 指向 $\text{node}$，令 $\text{node}.\text{prev}$ 指向 $\text{curr}$，最后令 $\text{curr}$ 指向 $\text{node}$，表示当前访问的页面是最新页面。

对于后退操作，将 $\text{curr}$ 向 $\text{prev}$ 方向移动，直到移动次数达到 $\text{steps}$ 次或者 $\text{curr}.\text{prev}$ 变为 $\text{null}$（此时 $\text{curr}$ 对应最早访问的页面），然后返回 $\text{curr}.\text{url}$。

对于前进操作，将 $\text{curr}$ 向 $\text{next}$ 方向移动，直到移动次数达到 $\text{steps}$ 次或者 $\text{curr}.\text{next}$ 变为 $\text{null}$（此时 $\text{curr}$ 对应最新访问的页面），然后返回 $\text{curr}.\text{url}$。

代码

class BrowserHistory {
    Node curr;

    public BrowserHistory(String homepage) {
        Node home = new Node(homepage);
        curr = home;
    }
    
    public void visit(String url) {
        Node node = new Node(url);
        curr.next = node;
        node.prev = curr;
        curr = node;
    }
    
    public String back(int steps) {
        while (curr.prev != null && steps > 0) {
            curr = curr.prev;
            steps--;
        }
        return curr.url;
    }
    
    public String forward(int steps) {
        while (curr.next != null && steps > 0) {
            curr = curr.next;
            steps--;
        }
        return curr.url;
    }
}

class Node {
    String url;
    Node prev;
    Node next;

    public Node(String url) {
        this.url = url;
    }
}

复杂度分析

• 时间复杂度：构造方法和访问操作的时间复杂度是 $O(1)$，后退和前进操作的时间复杂度是 $O(\text{steps})$。

• 空间复杂度：$O(n)$，其中 $n$ 是浏览器历史记录中的页面个数。

解法二

思路和算法

浏览器历史记录的访问和后退操作非常适合用栈实现，只需要使用一个栈即可支持访问和后退操作。对于前进操作，需要在后退操作的同时记录访问过的更新的页面，因此需要使用两个栈。

创建两个栈，分别为后退栈和前进栈，后退栈用于支持访问和后退操作，前进栈用于支持前进操作。对于任何操作，总是保证后退栈的栈顶元素为当前访问的页面。

初始化时，将 $\text{homepage}$ 入后退栈。

对于访问操作，将 $\text{url}$ 入后退栈，并将前进栈清空，因为当前访问的页面后面没有更新访问的页面。

对于后退操作，将后退栈内的元素依次出栈并入前进栈，直到操作的元素个数达到 $\text{steps}$ 个或者后退栈只剩下 $1$ 个元素，然后返回后退栈的栈顶元素。

对于前进操作，将前进栈内的元素依次出栈并入后退栈，直到操作的元素个数达到 $\text{steps}$ 个或者前进栈变为空，然后返回后退栈的栈顶元素。

代码

class BrowserHistory {
    Deque<String> backStack;
    Deque<String> forwardStack;

    public BrowserHistory(String homepage) {
        backStack = new ArrayDeque<String>();
        forwardStack = new ArrayDeque<String>();
        backStack.push(homepage);
    }
    
    public void visit(String url) {
        backStack.push(url);
        forwardStack.clear();
    }
    
    public String back(int steps) {
        while (backStack.size() > 1 && steps > 0) {
            forwardStack.push(backStack.pop());
            steps--;
        }
        return backStack.peek();
    }
    
    public String forward(int steps) {
        while (!forwardStack.isEmpty() && steps > 0) {
            backStack.push(forwardStack.pop());
            steps--;
        }
        return backStack.peek();
    }
}

复杂度分析

• 时间复杂度：构造方法和访问操作的时间复杂度是 $O(1)$，后退和前进操作的时间复杂度是 $O(\text{steps})$。

• 空间复杂度：$O(n)$，其中 $n$ 是浏览器历史记录中的页面个数。

解法三

思路和算法

上述两种解法的后退和前进操作的时间复杂度都是 $O(\text{steps})$，因为没有下标信息，无法快速定位到目标元素。如果使用动态数组存储浏览器历史记录，则可以使各项操作的时间复杂度都达到 $O(1)$。

创建动态数组，同时记录当前下标 $\text{index}$ 和最大下标 $\text{end}$，最大下标表示前进操作时的最后一个下标。

初始化时，将 $\text{homepage}$ 加入动态数组，将 $\text{index}$ 和 $\text{end}$ 都初始化为 $0$。

对于访问操作，将 $\text{index}$ 加 $1$，然后将 $\text{url}$ 赋到动态数组的下标 $\text{index}$ 处。特别地，如果动态数组中的元素个数小于或等于更新后的 $\text{index}$，则将 $\text{url}$ 添加到动态数组的末尾，此时动态数组的下标 $\text{index}$ 处的元素即为 $\text{url}$。由于当前访问的页面为最新访问的页面，因此令 $\text{end}=\text{index}$。

对于后退操作，将 $\text{index}$ 更新为 $\text{index}-\text{steps}$ 和 $0$ 中的最大值，则更新后的 $\text{index}$ 为动态数组中目标页面的下标，返回动态数组的下标 $\text{index}$ 处的元素。

对于前进操作，将 $\text{index}$ 更新为 $\text{index}+\text{steps}$ 和 $\text{end}$ 中的最小值，则更新后的 $\text{index}$ 为动态数组中目标页面的下标，返回动态数组的下标 $\text{index}$ 处的元素。

由于动态数组中可以根据下标快速定位元素，因此对于后退和前进操作，首先计算出目标页面的下标，然后根据下标得到目标页面，时间复杂度从 $O(\text{steps})$ 降到 $O(1)$。

代码

class BrowserHistory {
    List<String> history;
    int index;
    int end;

    public BrowserHistory(String homepage) {
        history = new ArrayList<String>();
        history.add(homepage);
        index = 0;
        end = 0;
    }

    public void visit(String url) {
        index++;
        if (index < history.size()) {
            history.set(index, url);
        } else {
            history.add(url);
        }
        end = index;
    }

    public String back(int steps) {
        index = Math.max(index - steps, 0);
        return history.get(index);
    }

    public String forward(int steps) {
        index = Math.min(index + steps, end);
        return history.get(index);
    }
}

复杂度分析

• 时间复杂度：构造方法和各项操作的时间复杂度是 $O(1)$。

• 空间复杂度：$O(n)$，其中 $n$ 是浏览器历史记录中的页面个数。