《五月集训》（第13天）——双向链表

前言：

五月集训，前面为学习内容，想要一起学习的可以看一看，最后的才是五月集训每天的作业。

一、知识点

相比于单向链表，双向链表多了一个指向前一个节点的指针。

二、课堂习题

这里的题均出自《算法零基础100讲》
自己先学啦🤭

三、作业

1472. 设计浏览器历史记录
430. 扁平化多级双向链表
剑指 Offer II 028. 展平多级双向链表
剑指 Offer 36. 二叉搜索树与双向链表
解题思路：
1.我采用了定义一个全局数组的方式记录操作步骤的方式，但对于今天的内容来说，应当是自己创建一个双向链表（大家别跟我学坏哟）；
2.运用了深度优先搜索的思想，将每个节点存储起来，然后再依次链接起来；
3.同上；
4.通用使用了深搜的思想，中序遍历二叉树，依次将每个节点链接起来。
代码：

class BrowserHistory {
    int index = -1;
    int end = -1;
    String[] step = new String[101];
    public BrowserHistory(String homepage) {
        step[++index] = homepage;
        end++;
    }
    
    public void visit(String url) {
        step[++index] = url;
        end = index;
    }
    
    public String back(int steps) {
        index = index > steps ? index - steps : 0;
        return step[index];
    }
    
    public String forward(int steps) {
        index = index + steps < end ? index + steps : end;
        return step[index];
    }
}

/**
 * Your BrowserHistory object will be instantiated and called as such:
 * BrowserHistory obj = new BrowserHistory(homepage);
 * obj.visit(url);
 * String param_2 = obj.back(steps);
 * String param_3 = obj.forward(steps);
 */

/*
// Definition for a Node.
class Node {
    public int val;
    public Node prev;
    public Node next;
    public Node child;
};
*/

class Solution {
    List<Node> list = new ArrayList<>();
    public Node flatten(Node head) {
        dfs(head);
        for(int i = 0;i < list.size()-1;i++){
            Node cur = list.get(i);
            Node pre = list.get(i+1);
            pre.prev = cur;
            cur.next = pre;
            cur.child = null; 
        }
        return head;
    }
    public void dfs(Node node){
        if(node == null){
            return;
        }
        list.add(node);
        dfs(node.child);
        dfs(node.next);
    }
}

/*
// Definition for a Node.
class Node {
    public int val;
    public Node prev;
    public Node next;
    public Node child;
};
*/

class Solution {
    List<Node> list = new ArrayList<>();
    public Node flatten(Node head) {
        dfs(head);
        for(int i = 0;i < list.size()-1;i++){
            Node cur = list.get(i);
            Node pre = list.get(i+1);
            pre.prev = cur;
            cur.next = pre;
            cur.child = null; 
        }
        return head;
    }
    public void dfs(Node node){
        if(node == null){
            return;
        }
        list.add(node);
        dfs(node.child);
        dfs(node.next);
    }
}

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val,Node _left,Node _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
    Node pre,head;
    public Node treeToDoublyList(Node root) {
        if(root == null){
            return null;
        }
        dfs(root);
        head.left = pre;
        pre.right = head;
        return head;
    }
    public void dfs(Node root){
        if(root == null){
            return;
        }
        dfs(root.left);
        if(pre == null){
            head = root;
        }else{
            pre.right = root;
        }
        root.left = pre;
        pre = root;
        dfs(root.right);
    }
}

四、总结

对于算法的掌握还是不够熟练，需要进行反复训练！
另外，剩下的课堂训练题目留到下个月的集训啦(●ˇ∀ˇ●)