剑指offer-重建二叉树

最新推荐文章于 2023-11-07 15:12:36 发布

原创最新推荐文章于 2023-11-07 15:12:36 发布 · 237 阅读

0 ·

CC 4.0 BY-SA版权

剑指offer 专栏收录该内容

59 篇文章

订阅专栏

本文介绍了一种根据二叉树的前序遍历和中序遍历结果重建二叉树的方法。通过递归地确定根节点，并划分左右子树，最终实现完整二叉树的重构。文中提供了详细的Java实现代码。

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

import java.util.Arrays;

public class 重建二叉树 {

	 public class TreeNode {
	      int val;
	      TreeNode left;
	      TreeNode right;
	      TreeNode(int x) { val = x; }
	 }
	 
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	}

	/*前序遍历结果的第一个节点肯定是跟节点，那么在中序节点中找到这个点，
	 * 这个点之前的是跟的左子树，之后的是右子数。。。循环*/
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
    	TreeNode node = null;
    	for (int i = 0; i < in.length; i++) {
			if (in[i]==pre[0]) {
				node = new TreeNode(in[i]);
				node.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1), 
						Arrays.copyOfRange(in, 0, i));
				node.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i+1, pre.length), 
						Arrays.copyOfRange(in, i+1, in.length));
			}
		}
		return node;
    }
}

第一次的写法：

package 剑指offer第二遍;

public class 重建二叉树 {

	class TreeNode {
		int val;
		TreeNode left;
		TreeNode right;

		TreeNode(int x) {
			val = x;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
	}

    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
    	TreeNode head= null;
    	if (pre.length==0||in.length==0) {
			return head;
		}
    	if (pre.length==1||in.length==1) {
    		head = new TreeNode(pre[0]);
			return head;
		}else {
			head = new TreeNode(pre[0]);
	    	int headindex = 0;
	    	for (int i = 0; i < in.length; i++) {
				if (in[i]==pre[0]) {
					headindex = i;
				}
			}
	    	
	    	int[] leftpre = new int[headindex];
	    	int[] leftin	= new int[headindex];
	    	for (int i = 0; i < leftpre.length; i++) {
	    		leftpre[i] = pre[i+1];
	    		leftin[i] = in[i];
			}
	    	head.left = reConstructBinaryTree(leftpre, leftin);
	    	
	    	int[] rightpre = new int[pre.length-headindex-1];
	    	int[] rightin = new int[pre.length-headindex-1];
	    	for (int i = 0; i < rightin.length; i++) {
				rightpre[i] = pre[headindex+i+1];
				rightin[i] = in[headindex+i+1];
			}
	    	head.right = reConstructBinaryTree(rightpre, rightin);
		}
		return head;
    }
}