java 二叉树的深度、平衡二叉树、二叉树的下一个结点

1. 二叉树的深度

1. 题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

2. 求解思路

可以用后序遍历，从最后一层往上累加层数，最后加上根节点。

3. 代码

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }

}

public class TreeDepth {

	public static void main(String[] args) {
		// 新建一棵二叉搜索树
		TreeNode root=new TreeNode(10);
		TreeNode n1=new TreeNode(5);
		TreeNode n2=new TreeNode(12);
		TreeNode n3=new TreeNode(4);
		TreeNode n4=new TreeNode(7);
		TreeNode n5=new TreeNode(11);
		TreeNode n6=new TreeNode(16);
		TreeNode n7=new TreeNode(19);
		root.left=n1;
		root.right=n2;
		n1.left=n3;
		n1.right=n4;
		n2.left=n5;
		n2.right=n6;
		n6.right=n7;
		
		System.out.println("后序遍历：");
		postOrderTraverse(root);
		
		int temp=TreeDep(root);
		System.out.println("\n"+"深度："+temp);

	}
	
	public static int TreeDep(TreeNode pRoot)
    {
        if(pRoot == null){
            return 0;
        }
        int left = TreeDep(pRoot.left);
        int right = TreeDep(pRoot.right);
        return Math.max(left, right) + 1;
    }
	
	// 后序遍历
    public static void postOrderTraverse(TreeNode node) {  
        if (node == null)  
            return;  
        postOrderTraverse(node.left);  
        postOrderTraverse(node.right);  
        System.out.print(node.val + " ");  
    }

}

运行：

后序遍历：
4 7 5 11 19 16 12 10 
深度：4

2. 平衡二叉树

1. 题目描述

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

2. 解题思路

仍然可以用后序遍历树深度，同时每次遍历时都对比每一节点下的子节点分支的深度是不是符合平衡二叉树的要求。

3. 代码

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }

}

public class IsBalanced_Solution {
	public static void main(String[] args) {		
		// 新建一棵二叉搜索树
		TreeNode root=new TreeNode(10);
		TreeNode n1=new TreeNode(5);
		TreeNode n2=new TreeNode(12);
		TreeNode n3=new TreeNode(4);
		TreeNode n4=new TreeNode(7);
		TreeNode n5=new TreeNode(11);
		TreeNode n6=new TreeNode(16);
		TreeNode n7=new TreeNode(19);
		TreeNode n8=new TreeNode(20);
			
		root.left=n1;
		root.right=n2;
		n1.left=n3;
		n1.right=n4;
		n2.left=n5;
		n2.right=n6;
		n6.right=n7;
		n7.right=n8;
		
		System.out.println("后序遍历：");
		postOrderTraverse(root);	
		
		isBalanced(root);
		System.out.println("\n"+"结果："+isBalance);
		
	}

	static boolean isBalance=true;
	public static int isBalanced(TreeNode pRoot)
    {
        if(pRoot == null){
            return 0;
        }
        int left = isBalanced(pRoot.left);
        int right = isBalanced(pRoot.right);
        if(Math.abs(left-right)>1){
            isBalance=false;
        }
        return Math.max(left, right) + 1;
    }
	
	
	// 后序遍历
    public static void postOrderTraverse(TreeNode node) {  
        if (node == null)  
            return;  
        postOrderTraverse(node.left);  
        postOrderTraverse(node.right);  
        System.out.print(node.val + " ");  
    }
	
	
}

运行：

后序遍历：
4 7 5 11 20 19 16 12 10 
结果：false

3. 二叉树的下一个结点

1. 题目描述

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

2. 解题思路

参考大神的思路如下：
首先知道中序遍历的规则是：左根右，然后作图

结合图，我们可发现分成两大类：1、有右子树的，那么下个结点就是右子树最左边的点；（eg：D，B，E，A，C，G） 2、没有右子树的，也可以分成两类，a)是父节点左孩子（eg：N，I，L） ，那么父节点就是下一个节点 ； b)是父节点的右孩子（eg：H，J，K，M）找他的父节点的父节点的父节点…直到当前结点是其父节点的左孩子位置。如果没有eg：M，那么他就是尾节点。

3. 代码

class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;
 
    TreeLinkNode(int val) {
        this.val = val;
    }
}


public class GetNext {

	public static void main(String[] args) {
		// 新建一棵二叉搜索树
		TreeLinkNode root=new TreeLinkNode(10);
		TreeLinkNode n1=new TreeLinkNode(5);
		TreeLinkNode n2=new TreeLinkNode(12);
		TreeLinkNode n3=new TreeLinkNode(4);
		TreeLinkNode n4=new TreeLinkNode(7);
		TreeLinkNode n5=new TreeLinkNode(11);
		TreeLinkNode n6=new TreeLinkNode(16);
		TreeLinkNode n7=new TreeLinkNode(19);
			
		root.left=n1;
		n1.next=root;		
		root.right=n2;
		n2.next=root;
		
		n1.left=n3;
		n3.next=n1;
		n1.right=n4;
		n4.next=n1;
		
		n2.left=n5;
		n5.next=n2;
		n2.right=n6;
		n6.next=n2;
		
		n6.right=n7;
		n7.next=n6;
		
		
		System.out.println("中序遍历：");
		inOrderTraverse(root);	
		System.out.print("\n"+"结果：");
		TreeLinkNode temp= getNxt(n5);
		System.out.print(n5.val+"->"+temp.val);

	}
	
	static TreeLinkNode getNxt(TreeLinkNode node)
    {
        if(node==null) return null;
        if(node.right!=null){    //如果有右子树，则找右子树的最左节点
            node = node.right;
            while(node.left!=null) node = node.left;
            return node;
        }
        while(node.next!=null){ //没右子树，则找第一个当前节点是父节点左孩子的节点
            if(node.next.left==node) return node.next;
            node = node.next;
        }
        return null;   //退到了根节点仍没找到，则返回null
    }
	
	// 中序遍历
    public static void inOrderTraverse(TreeLinkNode node) {  
        if (node == null)  
            return;  
        inOrderTraverse(node.left);  
        System.out.print(node.val + " ");  
        inOrderTraverse(node.right);  

    }
    
    
}

运行：

中序遍历：
4 5 7 10 11 12 16 19 
结果：11->12

数据结构方面的小白，仅做学习。。。