JAVA实现二叉树(二叉树的存储、二叉树的遍历)

参考了如下两篇文章：

http://zhangjunhd.blog.51cto.com/113473/82616

http://old.blog.edu.cn/user3/Newpoo/archives/2007/1683187.shtml

构造树如下:

package sherry.tyut;

import java.util.*;

 

//二叉树节点类

class BTNode {

    private char data;

    private BTNode left;

    private BTNode right;

    public char getData() {

       return data;

    }

    public void setData(char data) {

       this.data = data;

    }

    public BTNode getLeft() {

       return left;

    }

    public void setLeft(BTNode left) {

       this.left = left;

    }

    public BTNode getRight() {

       return right;

    }

    public void setRight(BTNode right) {

       this.right = right;

    }

    public BTNode(char data) {

       this(data,null,null);

    }

    public BTNode(char data, BTNode left, BTNode right) {

       this.data = data;

       this.left = left;

       this.right = right;

    }

}

//二叉树

public class BinaryTree {

    //属性

    private BTNode root;

    //set,get方法

    public BinaryTree(BTNode root) {

       this.root = root;

    }

    public BTNode getRoot() {

       return root;

    }

    //访问节点

    public static void visit(BTNode nood) {

       System.out.print(nood.getData()+" ");

    }

    //初始化

    public static BTNode init() {

       BTNode a = new BTNode('A');

       BTNode b = new BTNode('B', null, a);

       BTNode c = new BTNode('C');

       BTNode d = new BTNode('D', b, c);

       BTNode e = new BTNode('E');

       BTNode f = new BTNode('F', e, null);

       BTNode g = new BTNode('G', null, f);

       BTNode h = new BTNode('H', d, g);

       return h;

       //另外一个二叉树

//     BTNode e = new BTNode('E');

//     BTNode g = new BTNode('G');

//     BTNode i = new BTNode('I');

//     BTNode d = new BTNode('D', null, g);

//     BTNode b = new BTNode('B', d, null);

//     BTNode h = new BTNode('H', null, i);

//     BTNode f = new BTNode('F', h, null);

//     BTNode c = new BTNode('C', e, f);

//     BTNode a = new BTNode('A', b, c);

//     return a;

      

    }

    //递归实现前序遍历

    public static void preorder(BTNode nood) {

       if(nood != null) {

           visit(nood);

           preorder(nood.getLeft());

           preorder(nood.getRight());

       }

    }

    //递归实现中序遍历

    public static void inorder(BTNode nood) {

       if(nood != null) {

           inorder(nood.getLeft());

           visit(nood);

           inorder(nood.getRight());

       }

    }

    //递归实现后序遍历

    public static void postorder(BTNode nood) {

       if(nood != null) {

           postorder(nood.getLeft());

           postorder(nood.getRight());

           visit(nood);

       }

    }

    /*

     * 非递归实现前序遍历思路:

     * 1.根节点入栈

     * while(栈非空) {

     * (1)（根）节点出栈并访问

     *  (2)右子入栈，左子入栈

     * }

     */

    private static void nonrecuusivePreorder(BTNode nood) {

       Stack<BTNode> stack = new Stack<BTNode>();

       if(nood != null) {

           stack.push(nood);

           while(!stack.empty()) {

              nood = stack.pop();

              visit(nood);

              if(nood.getRight() != null)

                  stack.push(nood.getRight());

              if(nood.getLeft() != null)

                  stack.push(nood.getLeft());

           }

       }

    }

    /*

     * 非递归实现中序遍历

     * while(节点非空||栈非空) {

     * 1.（根）节点及其所有左子入栈

     *  2.栈顶出栈并访问，nood=nood.getRight()，无论有无右子，有则nood非空，无则nood空。

     * }

     *  //注意：nood为空，但栈非空同样可以进入while循环

     */  

    private static void nonrecuusiveInorder(BTNode nood) {

       Stack<BTNode> stack = new Stack<BTNode>();

       while(nood != null || !stack.empty()) {

//         if(nood != null)

//            System.out.println("-"+nood.getData()+"-");

           while(nood != null) {

//            if(nood != null)

//                System.out.println("--"+nood.getData()+"--");

              stack.push(nood);

              nood = nood.getLeft();

           }

           if(!stack.empty()) {

              nood = stack.pop();

              visit(nood);

              nood = nood.getRight();

           }

           /*

            * 当nood='A'时，nood != null进入while循环，A及A的所有左子入栈（当然A无子，不去管，至少A入栈了），

            * A出栈并扫描，由于A无子，故nood返回的是一个null，再次进入while循环!stack.empty()成立，由于

            * nood == null；所以while(nood != null)不会去执行，直接执行if(!stack.empty())。

            * 加上判断后，保证了nood != null恒成立，则每次进入循环时，总得执行while(nood != null)里面。

            */

//         if(nood.getRight() != null)//如加上这句错误。见上分析

//         nood = nood.getRight();//此句加到if条件里面更好

       }

    }

    /*

     * 非递归实现后序遍历思路：

     * while(节点非空||栈非空) {

     * 1.（根）节点及其所有左子入栈

     *  2.栈顶出栈

     *    (1)if(当前节点无右子 || 右子已访问)

     *      当前节点出栈并访问

     *    (2)else

     *      nood = nood.getRight()

     * }

     * //注意：nood = null设置的重要性

     * 问题：

     * 1.测试本次while循环结束，nood节点的值到底是什么？

     * 2.pop()的返回是当前弹出元素？还是弹出之后栈顶元素？

     */

    private static void nonrecuusivePostorder(BTNode nood) {

       BTNode pre = null;//上次被访问的节点

       Stack<BTNode> stack = new Stack<BTNode>();

       while(nood != null || !stack.empty()) {

           while(nood != null) {

              stack.push(nood);

              nood = nood.getLeft();

//            if(nood != null)//测试本次while循环结束，nood节点的值到底是？

//                System.out.println(nood.getData());

//            else//注意这里的nood最后为空，是因为执行了nood.getLeft()。

//                System.out.println(nood);//但是栈中为H,D,B三个元素。

           }

           nood = stack.peek();//故在此nood节点指向当前栈顶的元素。

//         System.out.println("-"+nood.getData()+"-");

           //当前节点无右子或右子已经访问过

           if(null == nood.getRight() || pre == nood.getRight()) {

              pre = stack.pop();//记录当前要访问的节点

//            System.out.println("pre="+pre.getData());//pop()返回当前弹出元素，弹之后

//            System.out.println(stack.peek().getData());//再查看栈顶时，栈顶元素改变。

              visit(pre);//pre值是当前弹出的元素，弹出之后，栈顶“指针”减一，指向下一个元素。

              nood = null;//防止下轮while循环再次访问所有的左子

           }

           else {//有右子

              nood = nood.getRight();//访问一个右子

           }

       }

    }

    /*

     * 层次遍历思路：

     * 1.根节点入队列

     * 2.while(队列非空) {

     * 队列头元素出队列并访问

     * 左子入队列，右子入队列

     * }

     * //注意Queue<BTNode> queue = new Queue<BTNode>();这样会报错的。

     * Queue是一个接口，接口就是一个隐式的抽象类，抽象类在Java中是不能实例化的 。

     */

    private static void levelorder(BTNode nood) {

       Queue<BTNode> queue = new LinkedList<BTNode>();

       if(nood != null) {

           queue.add(nood);

           while(!queue.isEmpty()) {

              nood = queue.poll();

              visit(nood);

              if(nood.getLeft() != null)

                  queue.add(nood.getLeft());

              if(nood.getRight() != null)

                  queue.add(nood.getRight());

           }

       }

    }

   

    public static void main(String[] args) {

       BinaryTree btree = new BinaryTree(init());

       System.out.println("---recuusive method---");

       System.out.print("Pre-Order:");

       preorder(btree.getRoot());

       System.out.println();

       System.out.print("In-Order:");

       inorder(btree.getRoot());

       System.out.println();

       System.out.print("Post-Order:");

       postorder(btree.getRoot());

       System.out.println();

       System.out.println("---nonrecuusive method---");

       System.out.print("nonrecPre-Order:");

       nonrecuusivePreorder(btree.getRoot());

       System.out.println();

       System.out.print("nonrecIn-Order:");

       nonrecuusiveInorder(btree.getRoot());

       System.out.println();

       System.out.print("nonrecPost-Order:");

       nonrecuusivePostorder(btree.getRoot());

       System.out.println();

       System.out.print("levelorder:");

       levelorder(btree.getRoot());

       System.out.println();

    }

   

}

 

输出结果：

---recuusive method---

Pre-Order:H D B A C G F E

In-Order:B A D C H G E F

Post-Order:A B C D E F G H

---nonrecuusive method---

nonrecPre-Order:H D B A C G F E

nonrecIn-Order:B A D C H G E F

nonrecPost-Order:A B C D E F G H

levelorder:H D G B C F A E