二叉树中相差最大的两个节点间的差的绝对值（层次遍历+递归先序）

题目描述：

输入一棵二叉树，二叉树中相差最大的两个节点间的差的绝对值（请注意程序效率）。

输入：

第一行输入有n，n表示结点数，结点号从1到n。根结点为1。 n <= 10。
接下来有n行，每行有两个个整型a和b，表示第i个节点的左右孩子孩子。a为左孩子，b为右孩子。当a为-1时，没有左孩子。当b为-1时，没有右孩子。

输出：

输出一个整型，表示树的深度。

样例输入：

7
2 3
4 5
-1 6
-1 -1
7 -1
-1 -1
-1 -1

样例输出：

6

输入的二叉树结构：

层次遍历，非递归实现，取得最大最小值，返回结果：

public static int getSubMaxValueOfTree(TreeNode root){
        if(root==null ||(root.right==null &&root.left==null))
            return -1;
        int max = root.value;
        int min = root.value;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode currentNode = queue.poll();
            if(max<currentNode.value){
                max =currentNode.value; 
            }
            if(min>currentNode.value){
                min = currentNode.value;
            }
            if(currentNode.left!=null)
                queue.add(currentNode.left);
            if(currentNode.right!=null)
                queue.add(currentNode.right);
        }
        return max-min;
    }

先序遍历，递归实现，取得最大最小值，返回结果：

public class GetAbsMaxBTree {
    static int max = Integer.MIN_VALUE;
    static int min = Integer.MAX_VALUE;
    public static int getSubMaxValueOfTreeByRecursion(TreeNode root){
        if(root!=null){
            {
                if(root.value>max)
                    max = root.value;
                if(root.value<min)
                    min = root.value;
            }
            getSubMaxValueOfTreeByRecursion(root.left);
            getSubMaxValueOfTreeByRecursion(root.right);
        }
        return max-min;
    }

已经AC的完整代码：

package oj.extend;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.LinkedList;
import java.util.Queue;

class TreeNode{
    int value;
    TreeNode right = null;
    TreeNode left = null;
    TreeNode(int value){
        this.value = value;
        this.left = this.right = null;
    }
}
public class GetAbsMaxBTree {

    public static int getSubMaxValueOfTree(TreeNode root){
        if(root==null ||(root.right==null &&root.left==null))
            return -1;
        int max = root.value;
        int min = root.value;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode currentNode = queue.poll();
            if(max<currentNode.value){
                max =currentNode.value; 
            }
            if(min>currentNode.value){
                min = currentNode.value;
            }
            if(currentNode.left!=null)
                queue.add(currentNode.left);
            if(currentNode.right!=null)
                queue.add(currentNode.right);
        }
        return max-min;
    }
    public static void main(String[] args) throws IOException {
        StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        while(cin.nextToken()!=cin.TT_EOF){
            int n = (int)cin.nval;
            int sign = 1;
            TreeNode []array = new TreeNode[n+1];
            array[sign++] = new TreeNode(1);
            TreeNode root = array[1];
            for(int i=1;i<=n;i++){
                cin.nextToken();
                int left =(int) cin.nval;
                cin.nextToken();
                int right =(int) cin.nval;
                if(left!=-1){
                    array[sign] =new TreeNode(left);
                    array[i].left = array[sign];
                    sign++;
                }else{
                    array[i].left = null;
                }
                if(right!=-1){
                    array[sign] = new TreeNode(right);
                    array[i].right = array[sign];
                    sign++;
                }              
            }
            int reslut = getSubMaxValueOfTree(root);
            System.out.println(reslut);
        }
    }
}