二叉树遍历(递归)

 // 测试二叉树遍历，递归算法
    public class TestBinaryTree {
    public static void main（String[] args） {
    Node<String> g = new Node<String>（"G", null, null）；
    Node<String> e = new Node<String>（"E", null, null）；
    Node<String> f = new Node<String>（"F", null, null）；
    Node<String> d = new Node<String>（"D", null, g）；
    Node<String> b = new Node<String>（"B", d, e）；
    Node<String> c = new Node<String>（"C", null, f）；
    Node<String> a = new Node<String>（"A", b, c）；
    System.out.println（"生成的二叉树："）；
    System.out.println（"            A"）；
    System.out.println（"            |     "）；
    System.out.println（"       |---------|"）；
    System.out.println（"       B         C"）；
    System.out.println（"       |         |"）；
    System.out.println（"  |---------|     -----|"）；
    System.out.println（"  D         E          F"）；
    System.out.println（"  |"）；
    System.out.println（"   ----|"）；
    System.out.println（"       G"）；
    System.out.println（"二叉树深度：" + BinaryTree.getDepth（a））；
    System.out.print（"前序遍历："）；
    BinaryTree.priorderTraversal（a）；
    System.out.println（）；
    System.out.print（"中序遍历："）；
    BinaryTree.inorderTraversal（a）；
    System.out.println（）；
    System.out.print（"后序遍历："）；
    BinaryTree.postorderTraversal（a）；
    System.out.println（）；
    }
    }
    // 二叉树
    class BinaryTree {
    // 前序遍历
    static <T> void priorderTraversal（Node<T> node） {
    if （node != null） {
    visitNode（node）；
    priorderTraversal（node.getLeftChild（））；
    priorderTraversal（node.getRightChild（））；
    }
    }
    // 中序遍历
    static <T> void inorderTraversal（Node<T> node） {
    if （node != null） {
    inorderTraversal（node.getLeftChild（））；
    visitNode（node）；
    inorderTraversal（node.getRightChild（））；
    }
    }
    // 后序遍历
    static <T> void postorderTraversal（Node<T> node） {
    if （node != null） {
    postorderTraversal（node.getLeftChild（））；
    postorderTraversal（node.getRightChild（））；
    visitNode（node）；
    }
    }
    // 二叉树深度
    static <T> int getDepth（Node<T> node） {
    if （node == null） {
    return 0;
    }
    int leftDepth = 0;
    int rightDepth = 0;
    leftDepth = getDepth（node.getLeftChild（））；
    rightDepth = getDepth（node.getRightChild（））；
    return （leftDepth > rightDepth ? leftDepth : rightDepth） + 1;
    }
    // 访问节点
    static <T> void visitNode（Node<T> node） {
    System.out.print（node.getKey（） + " "）；
    }
    }
    // 节点
    class Node<T> {
    private T key;
    private Node<T> leftChild;
    private Node<T> rightChild;
    public Node（） {
    }
    public Node（T key, Node<T> leftChild, Node<T> rightChild） {
    super（）；  www.2cto.com
    this.key = key;
    this.leftChild = leftChild;
    this.rightChild = rightChild;
    }
    public T getKey（） {
    return key;
    }
    public void setKey（T key） {
    this.key = key;
    }
    public Node<T> getLeftChild（） {
    return leftChild;
    }
    public void setLeftChild（Node<T> leftChild） {
    this.leftChild = leftChild;
    }
    public Node<T> getRightChild（） {
    return rightChild;
    }
    public void setRightChild（Node<T> rightChild） {
    this.rightChild = rightChild;
    }
    }

    输出结果：
    生成的二叉树：
    A
    |
    |---------|
    B         C
    |         |
    |---------|     -----|
    D         E          F
    |
    ----|
    G
    二叉树深度：4
    前序遍历：A B D G E C F
    中序遍历：D G B E A C F
    后序遍历：G D E B F C A

作者：Orson 
出处：http://www.cnblogs.com/java-class/ 
如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】 
如果，您希望更容易地发现我的新博客，不妨点击一下左下角的【关注我】 
如果，您对我的博客内容感兴趣，请继续关注我的后续博客，我是【Orson】 

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段 声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 

转载：http://www.cnblogs.com/java-class/archive/2013/05/04/3059406.html