构造二叉树

haotf · haotf · commit deb945db9c64 · 2022-02-12T23:01:33.000+08:00
diff --git a/105.从前序与中序遍历序列构造二叉树.java b/105.从前序与中序遍历序列构造二叉树.java
@@ -0,0 +1,57 @@
+/*
+ * @lc app=leetcode.cn id=105 lang=java
+ *
+ * [105] 从前序与中序遍历序列构造二叉树
+ */
+
+// @lc code=start
+/**
+ * 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 TreeNode buildTree(int[] preorder, int[] inorder) {
+        return traverse(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
+    }
+
+    private TreeNode traverse(int[] preorder, int pStart, int pEnd, int[] inorder, int iStart, int iEnd) {
+        if (pEnd < pStart || iEnd < iStart)
+            return null;
+
+        int root = preorder[pStart];
+        int index = getMaxIndex(inorder, iStart, iEnd, root);
+        int gap = index - iStart;
+
+        TreeNode left = traverse(preorder, pStart + 1, pStart + gap, inorder, iStart, index - 1);
+        TreeNode right = traverse(preorder, pStart + gap + 1, pEnd, inorder, index + 1, iEnd);
+
+        TreeNode node = new TreeNode(root);
+        node.left = left;
+        node.right = right;
+        return node;
+    }
+
+    private int getMaxIndex(int[] nums, int start, int end, int max) {
+        int index = 0;
+        for (int i = start; i <= end; i++) {
+            if (nums[i] == max) {
+                max = nums[i];
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+}
+// @lc code=end
diff --git a/106.从中序与后序遍历序列构造二叉树.java b/106.从中序与后序遍历序列构造二叉树.java
@@ -0,0 +1,57 @@
+/*
+ * @lc app=leetcode.cn id=106 lang=java
+ *
+ * [106] 从中序与后序遍历序列构造二叉树
+ */
+
+// @lc code=start
+/**
+ * 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 TreeNode buildTree(int[] inorder, int[] postorder) {
+        return traverse(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
+    }
+
+    private TreeNode traverse(int[] inorder, int iStart, int iEnd, int[] postorder, int pStart, int pEnd) {
+        if (pEnd < pStart || iEnd < iStart)
+            return null;
+
+        int root = postorder[pEnd];
+        int index = getMaxIndex(inorder, iStart, iEnd, root);
+        int gap = index - iStart;
+
+        TreeNode left = traverse(inorder, iStart, index - 1, postorder, pStart, pStart + gap - 1);
+        TreeNode right = traverse(inorder, index + 1, iEnd, postorder, pStart + gap, pEnd - 1);
+
+        TreeNode node = new TreeNode(root);
+        node.left = left;
+        node.right = right;
+        return node;
+    }
+
+    private int getMaxIndex(int[] nums, int start, int end, int max) {
+        int index = 0;
+        for (int i = start; i <= end; i++) {
+            if (nums[i] == max) {
+                max = nums[i];
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+}
+// @lc code=end
diff --git a/114.二叉树展开为链表.java b/114.二叉树展开为链表.java
@@ -0,0 +1,44 @@
+/*
+ * @lc app=leetcode.cn id=114 lang=java
+ *
+ * [114] 二叉树展开为链表
+ */
+
+// @lc code=start
+/**
+ * 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;
+        TreeNode parent = new TreeNode();
+        traverse(root, parent);
+    }
+
+    private TreeNode traverse(TreeNode root, TreeNode parent) {
+        if (root == null)
+            return parent;
+        parent.right = root;
+        parent = parent.right;
+        TreeNode left = parent.left;
+        TreeNode right = parent.right;
+        parent.left = null;
+        parent = traverse(left, parent);
+        parent = traverse(right, parent);
+        return parent;
+    }
+}
+// @lc code=end
diff --git a/116.填充每个节点的下一个右侧节点指针.java b/116.填充每个节点的下一个右侧节点指针.java
@@ -0,0 +1,51 @@
+/*
+ * @lc app=leetcode.cn id=116 lang=java
+ *
+ * [116] 填充每个节点的下一个右侧节点指针
+ */
+
+// @lc code=start
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {
+    }
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+    public Node connect(Node root) {
+        if (root == null) {
+            return root;
+        }
+        connectTwo(root.left, root.right);
+        return root;
+    }
+
+    private void connectTwo(Node left, Node right) {
+        if (left == null || right == null) {
+            return;
+        }
+        left.next = right;
+        connectTwo(left.left, left.right);
+        connectTwo(left.right, right.left);
+        connectTwo(right.left, right.right);
+    }
+}
+// @lc code=end
diff --git a/654.最大二叉树.java b/654.最大二叉树.java
@@ -0,0 +1,57 @@
+/*
+ * @lc app=leetcode.cn id=654 lang=java
+ *
+ * [654] 最大二叉树
+ */
+
+// @lc code=start
+/**
+ * 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 TreeNode constructMaximumBinaryTree(int[] nums) {
+        return traverse(nums, 0, nums.length - 1);
+    }
+
+    private TreeNode traverse(int[] nums, int start, int end) {
+        if (end < start)
+            return null;
+        // 获取最大值的key、value
+        int[] values = getMaxKeyVal(nums, start, end);
+        int max = values[0];
+        int index = values[1];
+        // 递归处理左右节点
+        TreeNode left = traverse(nums, start, index - 1);
+        TreeNode right = traverse(nums, index + 1, end);
+
+        TreeNode node = new TreeNode(max);
+        node.left = left;
+        node.right = right;
+        return node;
+    }
+
+    private int[] getMaxKeyVal(int[] nums, int start, int end) {
+        int max = Integer.MIN_VALUE;
+        int index = 0;
+        for (int i = start; i <= end; i++) {
+            if (nums[i] > max) {
+                max = nums[i];
+                index = i;
+            }
+        }
+        return new int[] { max, index };
+    }
+}
+// @lc code=end
diff --git a/889.根据前序和后序遍历构造二叉树.java b/889.根据前序和后序遍历构造二叉树.java
@@ -0,0 +1,60 @@
+/*
+ * @lc app=leetcode.cn id=889 lang=java
+ *
+ * [889] 根据前序和后序遍历构造二叉树
+ */
+
+// @lc code=start
+/**
+ * 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 TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
+        return traverse(preorder, 0, preorder.length - 1, postorder, 0, postorder.length - 1);
+    }
+
+    private TreeNode traverse(int[] preorder, int preStart, int preEnd, int[] postorder, int postStart, int postEnd) {
+        if (preEnd < preStart || postEnd < postStart)
+            return null;
+        if (preEnd == preStart) {
+            return new TreeNode(preorder[preStart]);
+        }
+
+        int leftRootVal = preorder[preStart + 1];
+        int index = getMaxIndex(postorder, postStart, postEnd, leftRootVal);
+        int leftSize = index - postStart + 1;
+
+        TreeNode left = traverse(preorder, preStart + 1, preStart + leftSize, postorder, postStart, index);
+        TreeNode right = traverse(preorder, preStart + leftSize + 1, preEnd, postorder, index + 1, postEnd - 1);
+
+        TreeNode node = new TreeNode(preorder[preStart]);
+        node.left = left;
+        node.right = right;
+        return node;
+    }
+
+    private int getMaxIndex(int[] nums, int start, int end, int max) {
+        int index = 0;
+        for (int i = start; i <= end; i++) {
+            if (nums[i] == max) {
+                max = nums[i];
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+}
+// @lc code=end
diff --git a/Node.java b/Node.java
@@ -0,0 +1,20 @@
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {
+    }
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
