【笔试】50、二叉树的深度&&判断平衡二叉树

二叉树结构

/**
 *题目：实现二叉树，输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。加上输入的前序遍历和中序遍历的结果中都不含重复的数字。
 *		例如输入前序遍历的序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出图2.6所示的二叉树并输出它的头结点。
 *		二叉树节点的定义如下：
 *时间：2015年8月26日11:32:52
 *文件：BinaryTreeNode.java
 *作者：cutter_point
 */
package bishi.Offer50.y2015.m08.d26;

public class BinaryTreeNode
{
	public int m_nValue;
	public BinaryTreeNode m_pLeft;
	public BinaryTreeNode m_pRight;
	
	public BinaryTreeNode()
	{
	}
	
	public BinaryTreeNode(int data)
	{
		m_nValue = data;
		m_pLeft = m_pRight = null;
	}
}

/**
 *题目：实现重建二叉树，输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。加上输入的前序遍历和中序遍历的结果中都不含重复的数字。
 *		例如输入前序遍历的序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出图2.6所示的二叉树并输出它的头结点。
 *		二叉树节点的定义如下：
 *时间：2015年8月26日11:40:36
 *文件：BinaryTree.java
 *作者：cutter_point
 */
package bishi.Offer50.y2015.m08.d26;

public class BinaryTree
{
	public BinaryTreeNode root;
	
	public static void main(String[] args)
	{
		int preorder[] = {1,2,4,7,3,5,6,8};
		int inorder[] = {4,7,2,1,5,3,8,6};
		BinaryTree bt = new BinaryTree();
		bt.construct(preorder, inorder);
		BinaryTreeNode test = bt.root;
	}
	
	/**
	 * 给出前序和总序，得到我们的二叉树
	 * @param Preorder
	 * @param Inorder
	 */
	public void construct(int Preorder[], int Inorder[])
	{
		if(Preorder == null || Inorder == null || Preorder.length != Inorder.length)
			return;
		
		try
		{
			root = constructCore(Preorder, 0, Preorder.length - 1, Inorder, 0, Inorder.length - 1);
		} 
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	
	/**
	 * 这个是根据前序和中序来遍历二叉树
	 * @param Preorder
	 * @param startPreorderIndex
	 * @param endPreorderIndex
	 * @param Inorder
	 * @param startInorderIndex
	 * @param endInorderIndex
	 * @return
	 * @throws Exception
	 */
	private BinaryTreeNode constructCore
	(
			int Preorder[], int startPreorderIndex, int endPreorderIndex, 
			int Inorder[], int startInorderIndex, int endInorderIndex
	) throws Exception
	{
		int rootValue = Preorder[startPreorderIndex];
		BinaryTreeNode btn = new BinaryTreeNode(rootValue);
		btn.m_pLeft = btn.m_pRight = null;
		
		//然后是递归终止条件
		if(startPreorderIndex == endPreorderIndex)
		{
			if(startInorderIndex == endInorderIndex && Preorder[startPreorderIndex] == Inorder[startInorderIndex])
			{
				return btn;
			}
			else
			{
				throw new Exception("前序和中序序列不匹配");
			}//else
		}//if
		
		int rootInorderIndex = startInorderIndex;
		while(Inorder[rootInorderIndex] != rootValue && rootInorderIndex <= endInorderIndex)
		{
			++rootInorderIndex;
		}//while
		
		//最后判断是找到了，还是没找到，到了末尾
		if(Inorder[rootInorderIndex] != rootValue && rootInorderIndex == endInorderIndex)
		{
			throw new Exception("前序和中序序列不匹配");
		}//if
		
		int leftLength = rootInorderIndex - startInorderIndex;
		if(leftLength > 0)
		{
			btn.m_pLeft = constructCore(Preorder, startPreorderIndex + 1, startPreorderIndex + leftLength, 
										Inorder, startInorderIndex, startInorderIndex + leftLength - 1);
		}//if
		
		if(leftLength < (endPreorderIndex - startPreorderIndex))
		{
			btn.m_pRight = constructCore(Preorder, startPreorderIndex + leftLength + 1, endPreorderIndex, 
										Inorder, startInorderIndex + leftLength + 1, endInorderIndex);
		}//if
		
		return btn;
	}
}

题目实现

/****************************************************************************************
 *题目：二叉树的深度
 *		1、输入一颗二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根，叶节点）形成树的一条路径，最长路径的长度为树的深度。
 *		class BinaryTreeNode
 *		{
 *			int m_nValue;
 *			BinaryTreeNode m_pLeft;
 *			BinaryTreeNode m_pRight;
 *		}
 *		2、输入一颗二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
 *		例如，图6.1中的二叉树就是一颗平衡二叉树
 *									1
 *						/						\
 *					   2						 3
 *				/				\						\
 *			   4				 5    					 6
 *							/
 *						   7
 *时间：2015年10月3日16:46:51
 *文件：TreeDepth.java
 *作者：cutter_point
 ****************************************************************************************/
package bishi.Offer50.y2015.m10.d03;

import org.junit.Test;

import bishi.Offer50.y2015.m08.d26.*;

public class TreeDepth
{
	/**
	 * 这个题的本质就是深度优先遍历树
	 * @param tree
	 * @return
	 */
	public int treeDep(BinaryTreeNode pRoot)
	{
		if(pRoot == null)
		{
			return 0;
		}//if
		
		
		int left = treeDep(pRoot.m_pLeft);
		int right = treeDep(pRoot.m_pRight);
		//我们输出一下我们的节点值
		System.out.println("当前访问的节点：" + pRoot.m_nValue);
		
		return (left > right) ? left + 1 : right + 1;
	}
	
	/**
	 * 判断是否是平衡二叉树，也是深度遍历的意识
	 * @param pRoot
	 * @return
	 */
	public boolean isBalanced(BinaryTreeNode pRoot)
	{
		if(pRoot == null)
			return true;
		
		//当两边的子树深度相差超过1的时候为false
		int left = treeDep(pRoot.m_pLeft);
		int right = treeDep(pRoot.m_pRight);
		int diff = left - right;
		if(diff > 1 || diff < -1)
			return false;
		//递归到所有的节点
		return isBalanced(pRoot.m_pLeft) && isBalanced(pRoot.m_pRight);
	}
	
	/**
	 * 这个每个节点遍历一次，然后获取相应的深度，进行比较
	 * @param pRoot
	 * @param dept
	 * @return
	 */
	public boolean isBalanced(BinaryTreeNode pRoot, int dept[])
	{
		if(pRoot == null)
		{
			dept[0] = 0;
			return true;
		}//if
		
		System.out.println("判断平衡数当前访问：" + pRoot.m_nValue);
		int left[] = new int[1]; int right[] = new int[1];
		//判断这个节点的左右子树的深度是否相差大于1
		if(isBalanced(pRoot.m_pLeft, left) && isBalanced(pRoot.m_pRight, right))
		{
			//求的其子树的深度差
			int dif = left[0] - right[0];
			if(dif <= 1 && dif >= -1)
			{
				//在可以继续的范围内
				dept[0] = 1 + (left[0] > right[0] ? left[0] : right[0]);
				return true;
			}//if
		}//if
		
		return false;
	}
	
	@Test
	public void test()
	{
		int preorder[] = {1,2,4,5,7,3,6};
		int inorder[] = {4,2,7,5,1,3,6};
		BinaryTree bt = new BinaryTree();
		bt.construct(preorder, inorder);
		TreeDepth td = new TreeDepth();
		int dept[] = new int[1];
		System.out.println("树深度" + td.treeDep(bt.root));
		System.out.println("是否是平衡二叉树：" + td.isBalanced(bt.root));
		System.out.println("是否是平衡二叉树2：" + td.isBalanced(bt.root, dept) + "\t深度:" + dept[0]);
	}
}