JAVA实现二叉树的遍历

首先简单的构造一个二叉树，然后通过前序、中序、后序遍历的递归和非递归形式遍历，同时也实现了层次遍历。

package sxd.learn.java;

import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

public class BinaryTree<T> {

    public static void main(String[] args){
        BinaryTree<Integer> binaryTree = new BinaryTree(1);
        binaryTree.createBinaryTree();

        System.out.println("前序遍历");
        binaryTree.preOrderTraverse();
        System.out.println();
        binaryTree.nrPeOrderTraverse();
        System.out.println();

        System.out.println("中序遍历");
        binaryTree.inOrderTraverse();
        System.out.println();
        binaryTree.nrInOrderTraverse();
        System.out.println();

        System.out.println("后序遍历");
        binaryTree.postOrderTraverse();
        System.out.println();
        binaryTree.nrPostOrderTraverse();
        System.out.println();

        System.out.println("层次遍历");
        binaryTree.levelTraverse();
        System.out.println();
    }

    private Node<T> root;

    public BinaryTree(T value){
        root = new Node<T>(value);
    }

    //简单构造二叉树
    public  void createBinaryTree(){
        Node node2 = new Node<Integer>(2);
        Node node3 = new Node<Integer>(3);
        Node node4 = new Node<Integer>(4);
        Node node5 = new Node<Integer>(5);
        Node node6 = new Node<Integer>(6);

        root.leftChild = node2;
        root.rightChild = node3;
        node2.leftChild = node4;
        node2.rightChild = node5;
        node3.leftChild = node6;
    }

    public boolean isEmpty(){
        return root == null;
    }

    //前序遍历的递归实现
    public void preOrderTraverse(){
        preOrderTraverse(root);
    }
    public void preOrderTraverse(Node<T> root){
        if(root != null){
            System.out.print(root.value + " ");
            preOrderTraverse(root.leftChild);
            preOrderTraverse(root.rightChild);
        }
    }

    //前序遍历的非递归实现
    public void nrPeOrderTraverse(){
        Stack<Node<T>> stack = new Stack<>();
        Node<T> node = root;
        while(node != null || !stack.isEmpty()){
            while(node != null){
                System.out.print(node.value + " ");
                stack.push(node);
                node = node.leftChild;
            }
            node = stack.pop();
            node = node.rightChild;
        }
    }

    //中序遍历的递归实现
    public void inOrderTraverse(){
        inOrderTraverse(root);
    }
    public void inOrderTraverse(Node<T> root){
        if(root != null){
            inOrderTraverse(root.leftChild);
            System.out.print(root.value + " ");
            inOrderTraverse(root.rightChild);
        }
    }

    //中序遍历的非递归实现
    public void nrInOrderTraverse(){
        Stack<Node<T>> stack = new Stack<>();
        Node<T> node = root;
        while(node != null || !stack.isEmpty()){
            while(node != null){
                stack.push(node);
                node = node.leftChild;
            }
            node = stack.pop();
            System.out.print(node.value+ " ");
            node = node.rightChild;
        }
    }

    //后序遍历的递归实现
    public void postOrderTraverse(){
        postOrderTraverse(root);
    }
    public void postOrderTraverse(Node<T> root){
        if(root != null){
            postOrderTraverse(root.leftChild);
            postOrderTraverse(root.rightChild);
            System.out.print(root.value + " ");
        }
    }

    //后序遍历的非递归实现
    public void nrPostOrderTraverse(){
        Stack<Node<T>> stack = new Stack<>();
        Node<T> node = root;
        Node<T> preNode = null;
        while(node != null || !stack.isEmpty()){
            while(node != null){
                stack.push(node);
                node = node.leftChild;
            }

            node = stack.peek();
            if(node.rightChild == null || node.rightChild == preNode){
                System.out.print(node.value + " ");
                node = stack.pop();
                preNode = node;
                node = null;
            }else{
                node = node.rightChild;
            }
        }
    }

    public void levelTraverse(){
        Queue<Node<T>> queue = new LinkedBlockingQueue<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            Node<T> temp = queue.poll(); 
            if(temp != null){
                 System.out.print(temp.value +  " ");
                 if(temp.leftChild != null)
                     queue.offer(temp.leftChild);
                 if(temp.rightChild != null)
                     queue.offer(temp.rightChild);
            }
        }
    }

    class Node<T>{
        T value;
        Node<T> leftChild;
        Node<T> rightChild;
        Node(T value){
            this.value = value;
            leftChild = null;
            rightChild = null;
        }
    }
}