algorithm/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2025-07-09 19:44:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

修改0106从中序与后序遍历序列构造二叉树 Java版本

Browse Source 
将0106和0105的Java版本进行了修改，采用了map来存储位置信息，加快定位；并且代码更容易看懂
This commit is contained in:
lizhendong128
2022-06-03 21:42:36 +08:00
parent f03f8d2b61
commit a2a2cf6027
1 changed files with 39 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
problems/0106.从中序与后序遍历序列构造二叉树.md
View File

@ -584,35 +584,29 @@ tree2 的前序遍历是[1 2 3]， 后序遍历是[3 2 1]。
```java ```java
class Solution { class Solution {
Map<Integer, Integer> map; // 方便根据数值查找位置
public TreeNode buildTree(int[] inorder, int[] postorder) { public TreeNode buildTree(int[] inorder, int[] postorder) {
return buildTree1(inorder, 0, inorder.length, postorder, 0, postorder.length); map = new HashMap<>();
for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
map.put(inorder[i], i);
}
return findNode(inorder, 0, inorder.length, postorder,0, postorder.length); // 前闭后开
} }
public TreeNode buildTree1(int[] inorder, int inLeft, int inRight,
int[] postorder, int postLeft, int postRight) { public TreeNode findNode(int[] inorder, int inBegin, int inEnd, int[] postorder, int postBegin, int postEnd) {
// 没有元素了 // 参数里的范围都是前闭后开
if (inRight - inLeft < 1) { if (inBegin >= inEnd || postBegin >= postEnd) { // 不满足左闭右开，说明没有元素，返回空树
return null; return null;
} }
// 只有一个元素了 int rootIndex = map.get(postorder[postEnd - 1]); // 找到后序遍历的最后一个元素在中序遍历中的位置
if (inRight - inLeft == 1) { TreeNode root = new TreeNode(inorder[rootIndex]); // 构造结点
return new TreeNode(inorder[inLeft]); int lenOfLeft = rootIndex - inBegin; // 保存中序左子树个数，用来确定后序数列的个数
} root.left = findNode(inorder, inBegin, rootIndex,
// 后序数组postorder里最后一个即为根结点 postorder, postBegin, postBegin + lenOfLeft);
int rootVal = postorder[postRight - 1]; root.right = findNode(inorder, rootIndex + 1, inEnd,
TreeNode root = new TreeNode(rootVal); postorder, postBegin + lenOfLeft, postEnd - 1);
int rootIndex = 0;
// 根据根结点的值找到该值在中序数组inorder里的位置
for (int i = inLeft; i < inRight; i++) {
if (inorder[i] == rootVal) {
rootIndex = i;
break;
}
}
// 根据rootIndex划分左右子树
root.left = buildTree1(inorder, inLeft, rootIndex,
postorder, postLeft, postLeft + (rootIndex - inLeft));
root.right = buildTree1(inorder, rootIndex + 1, inRight,
postorder, postLeft + (rootIndex - inLeft), postRight - 1);
return root; return root;
} }
} }
@ -622,31 +616,29 @@ class Solution {
```java ```java
class Solution { class Solution {
Map<Integer, Integer> map;
public TreeNode buildTree(int[] preorder, int[] inorder) { public TreeNode buildTree(int[] preorder, int[] inorder) {
return helper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1); map = new HashMap<>();
} for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
map.put(inorder[i], i);
public TreeNode helper(int[] preorder, int preLeft, int preRight,
int[] inorder, int inLeft, int inRight) {
// 递归终止条件
if (inLeft > inRight || preLeft > preRight) return null;
// val 为前序遍历第一个的值，也即是根节点的值
// idx 为根据根节点的值来找中序遍历的下标
int idx = inLeft, val = preorder[preLeft];
TreeNode root = new TreeNode(val);
for (int i = inLeft; i <= inRight; i++) {
if (inorder[i] == val) {
idx = i;
break;
}
} }
// 根据 idx 来递归找左右子树 return findNode(preorder, 0, preorder.length, inorder, 0, inorder.length); // 前闭后开
root.left = helper(preorder, preLeft + 1, preLeft + (idx - inLeft), }
inorder, inLeft, idx - 1);
root.right = helper(preorder, preLeft + (idx - inLeft) + 1, preRight, public TreeNode findNode(int[] preorder, int preBegin, int preEnd, int[] inorder, int inBegin, int inEnd) {
inorder, idx + 1, inRight); // 参数里的范围都是前闭后开
if (preBegin >= preEnd || inBegin >= inEnd) { // 不满足左闭右开，说明没有元素，返回空树
return null;
}
int rootIndex = map.get(preorder[preBegin]); // 找到前序遍历的第一个元素在中序遍历中的位置
TreeNode root = new TreeNode(inorder[rootIndex]); // 构造结点
int lenOfLeft = rootIndex - inBegin; // 保存中序左子树个数，用来确定前序数列的个数
root.left = findNode(preorder, preBegin + 1, preBegin + lenOfLeft + 1,
inorder, inBegin, rootIndex);
root.right = findNode(preorder, preBegin + lenOfLeft + 1, preEnd,
inorder, rootIndex + 1, inEnd);
return root; return root;
} }
} }