Java实现二叉树的遍历

一、二叉树结点类

/**
 * @Description: 二叉树结点类
 */
public class BinaryTreeNode<T>{
    private Integer Level; //结点的层级
    private T data; //结点的数据域
    private BinaryTreeNode<T> leftChild;//左孩子结点
    private BinaryTreeNode<T> rightChild; //右孩子结点

    public BinaryTreeNode() {}

    /*
    * @desc: 构造方法
    * @param data: 结点的数据域
    * @return:
    */
    public BinaryTreeNode( T data) {
        this.data = data;
        this.leftChild = null;
        this.rightChild = null;
    }

    public Integer getLevel() {
        return Level;
    }

    public void setLevel(Integer level) {
        Level = level;
    }

    public T getData() {
        return this.data;
    }
    
    public void setData(T newData) {
        this.data = newData;
    }

    public BinaryTreeNode<T> getLeftChild() {
        return leftChild;
    }

    public void setLeftChild(BinaryTreeNode<T> leftChild) {
        this.leftChild = leftChild;
    }

    public BinaryTreeNode<T> getRightChild() {
        return rightChild;
    }

    public void setRightChild(BinaryTreeNode<T> rightChild) {
        this.rightChild = rightChild;
    }

    public boolean isLeaf() {
        return (this.leftChild == null) && (this.rightChild == null);
    }

    /*
    * @desc: 返回以该结点为根的子树中的结点的个数(包括根结点)
    * @param : 
    * @return: int
    */
    public int getNumberOfNodes() {
        int leftNumber = 0;
        int rightNumber = 0;
        if (leftChild != null){
            leftNumber = leftChild.getNumberOfNodes();//递归
        }
        if (rightChild != null){
            rightNumber = rightChild.getNumberOfNodes();//递归
        }
        return 1 + leftNumber + rightNumber;
    }

    public int getHeight() {
        return getHeight(this);
    }
    /*
    * @desc: 返回以此结点为根的子树的高度
    * @param node: 
    * @return: int
    */
    private int getHeight(BinaryTreeNode<T> node){
        int height = 0;
        if (node != null){
            height = 1 + Math.max(getHeight(node.leftChild),getHeight(node.rightChild));
        }
        return height;
    }
}

二、二叉树接口

public interface BinaryTreeInterface<T> {
    public T getRootData(); //获取根结点
    public int getHeight(); //获取树的高度
    public int getNumberOfNodes();//获取树的结点数
    public boolean isEmpty(); //判断树是否为空
    public void clear(BinaryTreeNode<T> node); //清空树
    public void visited(BinaryTreeNode<T> subNode); //访问二叉树的结点
    public void preOrder(BinaryTreeNode<T> node);//前序遍历
    public void inOrder(BinaryTreeNode<T> node);//中序遍历
    public void postOrder(BinaryTreeNode<T> node);//后序遍历
    public void levelOrder(BinaryTreeNode<T> node);//层次遍历

    public void noRecursionPre(BinaryTreeNode<T> node);//非递归前序遍历
    public void noRecursionIn(BinaryTreeNode<T> node); //非递归中序遍历
    public void noRecursionPost(BinaryTreeNode<T> node); //非递归中序遍历
    public void noRecursionlevel(BinaryTreeNode<T> node);//层次遍历
}

三、二叉树类(实现接口)

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * @Description: 二叉树类
 * @Version:
 */

public class BinaryTree<T> implements BinaryTreeInterface<T>{

    private BinaryTreeNode<T> root = null; //树的根结点

    public BinaryTree(T rootData) {
        this.root = new BinaryTreeNode<T>(rootData);
    }

    public BinaryTree(BinaryTreeNode<T> root) {
        this.root = root;
    }

    @Override
    /*
    * @desc: 返回树的根节点的数据域
    * @param : 
    * @return: T
    */
    public T getRootData() {
        T rootData = null;
        if (root != null){
            rootData = root.getData(); //调用结点的getData()返回结点的数据域
        }
        return rootData;
    }

    @Override
    /*
    * @desc: 返回二叉树的高度
    * @param : 
    * @return: int
    */
    public int getHeight() {
        return root.getHeight();//二叉树的高度即为以根结点为根的子树的高度
    }

    @Override
    /*
    * @desc: 返回二叉树中结点的个数
    * @param :
    * @return: int
    */
    public int getNumberOfNodes() {
        return root.getNumberOfNodes();
    }

    @Override
    /*
    * @desc: 判断树是否为空
    * @param :
    * @return: boolean
    */
    public boolean isEmpty() {
        return root == null;
    }

    @Override
    /*
    * @desc: 清空二叉树
    * @param :
    * @return: void
    */
    public void clear(BinaryTreeNode<T> node) {
        if (node != null){
            clear(node.getLeftChild());
            clear(node.getRightChild());
            node = null;
        }
    }


    @Override
    public void visited(BinaryTreeNode<T> subNode) {
        System.out.println("Level:"+subNode.getLevel()+"-----Name:"+subNode.getData());
    }

    @Override
    /*
    * @desc: 前序遍历
    * @param node: 结点
    * @return: void
    */
    public void preOrder(BinaryTreeNode<T> node) {
        if (node != null){
            visited(node);
            preOrder(node.getLeftChild());
            preOrder(node.getRightChild());
        }
    }

    @Override
    /*
    * @desc: 中序遍历
    * @param node: 结点
    * @return: void
    */
    public void inOrder(BinaryTreeNode<T> node) {
        if (node != null){
            inOrder(node.getLeftChild());
            visited(node);
            inOrder(node.getRightChild());
        }
    }

    @Override
    /*
    * @desc: 后续遍历
    * @param node: 结点
    * @return: void
    */
    public void postOrder(BinaryTreeNode<T> node) {
        if (node != null){
            postOrder(node.getLeftChild());
            postOrder(node.getRightChild());
            visited(node);
        }
    }

    @Override
    /*
    * @desc: 递归实现层次遍历
    * @param node:
    * @return: void
    */
    public void levelOrder(BinaryTreeNode<T> node) {
        if (node == null){
            return;
        }
        int depth = node.getHeight();
        for (int i=1;i<=depth;i++){
            levelOrder(node,i);
        }
    }

    private void levelOrder(BinaryTreeNode<T> node, int level) {
        if (node ==  null || level < 1){
            return;
        }
        if (level == 1){
            visited(node);
        }
        //遍历左子树
        levelOrder(node.getLeftChild(),level-1);
        //遍历右子树
        levelOrder(node.getRightChild(),level-1);
    }

    @Override
    /*
    * @desc: 非递归实现前序遍历
    * @param node: 结点
    * @return: void
    */
    public void noRecursionPre(BinaryTreeNode<T> node) {
        Stack<BinaryTreeNode> stack = new Stack<>(); //创建栈
        BinaryTreeNode<T> p = node;
        while( p != null || stack.size()>0){
            while (p != null){
                visited(p);
                stack.push(p);
                p = p.getLeftChild();
            }
            while (stack.size()>0){
                if (p != null){
                    visited(p);
                }
                p = stack.pop();
                p = p.getRightChild();
            }
        }
    }

    @Override
    /*
    * @desc: 非递归中序遍历
    * @param node: 结点
    * @return: void
    */
    public void noRecursionIn(BinaryTreeNode<T> node) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        BinaryTreeNode<T> p = node;
        while (p != null || stack.size()>0){
            while (p != null){ //存在左子树
                stack.push(p);
                p = p.getLeftChild();
            }
            if (stack.size()>0){ //栈非空
                p = stack.pop();
                visited(p);
                p = p.getRightChild();
            }
        }
    }

    @Override
    /*
    * @desc: 后序遍历的非递归实现
    * @param node: 结点
    * @return: void
    */
    public void noRecursionPost(BinaryTreeNode<T> node) {
        Stack<BinaryTreeNode> stack = new Stack<>();
        BinaryTreeNode<T> temp = node; //记录当前结点
        BinaryTreeNode<T> prev = null; //上一次访问的结点

        while (temp != null || !stack.empty()){
            while (temp != null){ //1.将根结点及其左孩子入栈
                stack.push(temp);
                temp = temp.getLeftChild();
            }
            if (!stack.empty()){
                temp = stack.peek(); //2.读取栈顶元素
                //3.没有右孩子，或者右孩子已经被访问过
                if (temp.getRightChild() == null || temp.getRightChild() == prev){
                    //则可以访问栈顶元素
                    temp = stack.pop();
                    visited(temp);
                    prev = temp; //标记上一次访问的结点
                    temp = null;
                }else{ //4.存在没有被访问的右孩子
                    temp = temp.getRightChild();
                }
            }
        }
    }

    @Override
    /*
    * @desc: 非递归层次遍历
    * @param node: 结点
    * @return: void
    */
    public void noRecursionlevel(BinaryTreeNode<T> node) {
        if (node == null){
            return;
        }
        BinaryTreeNode<T> temp;
        Queue<BinaryTreeNode> queue = new LinkedList<>(); //定义队列
        queue.add(node);

        while (queue.size() != 0){
            temp = queue.poll(); //出队
            visited(temp);
            if (temp.getLeftChild() != null){
                queue.offer(temp.getLeftChild()); //入队
            }
            if (temp.getRightChild() != null){
                queue.offer(temp.getRightChild());
            }
        }
    }
}

四、测试

import org.junit.Test;

import static org.junit.Assert.*;

public class BinaryTreeTest {

 /*
   构建一棵二叉树

          A
         / \
        B   C 
       / \   \ 
      D   E   F
*/

    @Test
    public void testTree(){

        BinaryTreeNode<String> A = new BinaryTreeNode<>("A");
        BinaryTreeNode<String> B = new BinaryTreeNode<>("B");
        BinaryTreeNode<String> C = new BinaryTreeNode<>("C");
        BinaryTreeNode<String> D = new BinaryTreeNode<>("D");
        BinaryTreeNode<String> E = new BinaryTreeNode<>("E");
        BinaryTreeNode<String> F = new BinaryTreeNode<>("F");

         F.setLevel(3);
         E.setLevel(3);
         D.setLevel(3);
         C.setLevel(2);
         B.setLevel(2);

         A.setLevel(1);
         A.setLeftChild(B);
         A.setRightChild(C);

         B.setLeftChild(D);
         B.setRightChild(E);

         C.setRightChild(F);

         BinaryTree<String> bt = new BinaryTree<String>(A);

        System.out.println("根结点是："+bt.getRootData());
        System.out.println("树的结点数："+bt.getNumberOfNodes());
        System.out.println("树高度："+bt.getHeight());

        System.out.println("非递归前序遍历：");
        bt.noRecursionPre(A);

        System.out.println("非递归中序遍历：");
        bt.noRecursionIn(A);

        System.out.println("非递归后序遍历：");
        bt.noRecursionPost(A);

        System.out.println("非递归层次遍历：");
        bt.noRecursionlevel(A);

    }
}