遍历二叉树

本博客将讲解的是一个阿里巴巴校招的在线笔试题中的一个算法！

其原题为：
写一个函数，输入一个二叉树，树中每个节点存放了一个整数值，函数返回这棵二叉树 中相差最大的两个节点间的差值绝对值。请注意程序效率。

解题思路：通过遍历二叉树，得到该二叉树中结点最大值和最小值！

我们举例的二叉树样本如下：

对于二叉树的结点，我们知道其有左子树和右子树！

结点的JavaBean类的关键代码如下：

public class Node {
    private Node lNode;
    private Node rNode;
    private int value;

    /**
     * 叶子节点
     * 
     * @param value
     */
    public Node(int value) {
        this.value = value;
    }

    /**
     * 非叶子节点
     * 
     * @param lNode
     * @param rNode
     * @param value
     */
    public Node(Node lNode, Node rNode, int value) {
        this.lNode = lNode;
        this.rNode = rNode;
        this.value = value;
    }

    public Node getlNode() {
        return lNode;
    }

    public void setlNode(Node lNode) {
        this.lNode = lNode;
    }

    public Node getrNode() {
        return rNode;
    }

    public void setrNode(Node rNode) {
        this.rNode = rNode;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

}

按照上图的二叉树，初始化结点。

测试类的关键代码如下:

public class NodeMain {
    Node rootNode = null;
    static private int minValue = 0;
    static private int maxValue = 0;

    public static void main(String[] args) {
        NodeMain nodeMain = new NodeMain();
        nodeMain.InitNode();
        // 遍历二叉树-- 前序遍历
        if (nodeMain.rootNode == null) {
            System.out.println("二叉树为空");
        } else {
            // 每一节点的前序遍历,
            nodeMain.bianLiNode(nodeMain.rootNode);
        }
        System.out.println();
        System.out.println("最小值：  " + minValue);
        System.out.println("最大值：  " + maxValue);
        System.out.println("结果：  " + Math.abs(maxValue-minValue));
    }

    /**
     * 初始化节点
     */
    private void InitNode() {
        rootNode = new Node(10);
        Node threeOne = new Node(-1);
        Node threeTwo = new Node(19);
        Node threeThree = new Node(2);
        Node twoOne = new Node(threeOne, threeTwo, 3);
//      Node twoOne = new Node(3);
//      Node twoTwo = new Node(5);
//      twoOne.setlNode(threeOne);
//      twoOne.setrNode(threeTwo);
//      twoTwo.setlNode(threeThree);
        Node twoTwo = new Node(threeThree, null, 5);
        rootNode.setlNode(twoOne);
        rootNode.setrNode(twoTwo);
        Node fourOne=new Node(-8);
        Node fourTwo=new Node(45);
        threeTwo.setlNode(fourOne);
        threeTwo.setrNode(fourTwo);
    }

    /**
     * 每一个节点的前序遍历,递归实现
     * 
     * @param node
     */
    public void bianLiNode(Node node) {
        System.out.println(node.getValue());  //输出节点的值
        if (node.getValue() > maxValue) {
            maxValue = node.getValue();
        }
        if (node.getValue() < minValue) {
            minValue = node.getValue();
        }
        if (node.getlNode() == null && node.getrNode() == null) {
            return;
        } else {
            // 开始遍历
            if (node.getlNode() != null) {
                bianLiNode(node.getlNode());
            }
            if (node.getrNode() != null) {
                bianLiNode(node.getrNode());
            }
        }
    }
}

运行之后的结果为：

如有错误或者疑问欢迎评论！

联系方式：840284038（qq）