构造二叉树集锦

最新推荐文章于 2024-07-12 18:02:43 发布

*平芜尽处是春山*

最新推荐文章于 2024-07-12 18:02:43 发布

阅读量472

点赞数 1

分类专栏：数据结构文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/m0_48046714/article/details/124641198

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

构造二叉树集锦

105. 从前序与中序遍历序列构造二叉树
- 106. 从中序与后序遍历序列构造二叉树
- - 889. 根据前序和后序遍历构造二叉树

105. 从前序与中序遍历序列构造二叉树

class Solution {
    int index = 0;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTreeInternal(preorder,inorder,0,inorder.length);
    }

    public TreeNode buildTreeInternal(int[] preOrder,int[] inOrder,int left,int right) {
        if(left >= right) {
            return null;
        }
        if(index >= preOrder.length) {
            return null;
        }
        TreeNode root = new TreeNode(preOrder[index]);
        index++;
        int pos = find(inOrder,left,right,root.val);
        root.left = buildTreeInternal(preOrder,inOrder,left,pos);
        root.right = buildTreeInternal(preOrder,inOrder,pos + 1,right);
        return root;
    }

    private int find(int[] inOrder,int left,int right,int val) {
        for(int i = left;i < right;i++) {
            if(inOrder[i] == val) {
                return i;
            }
        }
        return -1;
    }
}

运行截图：
在这里插入图片描述

106. 从中序与后序遍历序列构造二叉树

class Solution {
    Map<Integer,Integer> map = new HashMap<> ();
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        int[] preOrder = reverse(inorder,postorder);
        return buildTreeInteral(preOrder,inorder,0,inorder.length);
        }

        int index = 0;
        public TreeNode buildTreeInteral(int[] preOrder,int[] inOrder,int left,int right) {
            if(left >= right) {
                return null;
            }
            if(index >= preOrder.length) {
                return null;
            }
            TreeNode root = new TreeNode(preOrder[index]);
            index++;
            int pos = map.get(root.val);
            root.right = buildTreeInteral(preOrder,inOrder,pos + 1,right);
            root.left = buildTreeInteral(preOrder,inOrder,left,pos);
            return root;
        }
        private int[] reverse(int[] inorder,int[] postorder) {
            int[] ret = new int[postorder.length];
            for(int i = 0;i < ret.length;i++) {
                ret[i] = postorder[ret.length - 1 -i];
            }
            for(int i = 0;i < inorder.length;i++) {
                map.put(inorder[i],i);
            }
            return ret;
        }
}

运行截图：
在这里插入图片描述

889. 根据前序和后序遍历构造二叉树

class Solution { 
    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) { 
        int length = preorder.length; 
        TreeNode root = new TreeNode(preorder[0]); 
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>(); 
        stack.push(root); 
        int postorderIndex = 0; 
        for (int i = 1; i < length; i++) { 
            TreeNode prev = stack.peek(); 
            TreeNode curr = new TreeNode(preorder[i]); 
            if (prev.val != postorder[postorderIndex]) { 
                prev.left = curr; 
                stack.push(curr);
                } else { 
                    while (stack.peek().val == postorder[postorderIndex]) { 
                        stack.pop(); 
                        postorderIndex++;
                        } 
                        prev = stack.peek(); 
                        prev.right = curr; 
                        stack.push(curr); 
                        }
        } 
                        return root;
    }
}