LeeCode打卡第二十七天

LeeCode打卡第二十七天

第一题：二叉树展开为链表（LeeCode第114题）:

给你二叉树的根结点 root ，请你将它展开为一个单链表：

• 展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
• 展开后的单链表应该与二叉树 先序遍历 顺序相同。

### 解法一：在原二叉树上进行修改

主要思想：前序遍历的时候，根节点左子树最右的孩子的后一个节点为根节点的右孩子。根据这个特性，直接在原二叉树上进行修改，将右孩子放到左子树的最右边的孩子的右子树上，再将左子树置为null即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        while(root != null){
            if(root.left != null){
                TreeNode pre = root.left;
                while(pre.right != null) pre = pre.right;
            pre.right = root.right;
            root.right = root.left;
            root.left = null;
            }
            root = root.right;
        }
    }
}

解法二：利用辅助链表

主要思想：先前序遍历一遍整个二叉树，将遍历的节点依次存入链表中，再将链表中的值按顺序存入二叉树的右子树，并将左子树置为null

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        if(root == null) return;
        LinkedList<TreeNode> res = new LinkedList<>();

        dfs(root, res);
        TreeNode head = res.removeFirst();
        head.left = null;
        while(res.size() > 0){
            TreeNode tmp = res.removeFirst();
            tmp.left = null;
            head.right = tmp;
            head = head.right;
        }
    }
    private void dfs(TreeNode root, List<TreeNode> res){
        if(root == null) return;
        res.add(root);
        dfs(root.left, res);
        dfs(root.right, res);
    }
}

第二题：从前序和中序遍历序列构造二叉树（LeeCode第105题）:

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

主要思想：主要是利用递归的思想。对于前序遍历来说，他的第一个值为二叉树的根节点，将中序遍历存入HashMap可以通过根节点的位置划分左右子树，这样就饿可以递归地划分左右子树构造二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    HashMap<Integer, Integer> inoMap = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for(int i = 0; i< preorder.length; i++){
            inoMap.put(inorder[i], i);
        }
        return Build(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1);
        
    }
    private TreeNode Build(int[] pre, int preStart, int preEnd, int[] in, int inStart, int inEnd){
        if(preStart > preEnd) return null;
        TreeNode root = new TreeNode(pre[preStart]);
        int index = inoMap.get(root.val);
        int left = index - inStart;
        root.left = Build(pre, preStart + 1, preStart + left, in, inStart, index - 1);
        root.right = Build(pre, preStart + left + 1,preEnd, in, index + 1, inEnd);
        return root;
    }
}