二叉树java遍历

节点定义

-节点的值 T
-左子节点
-右子节点
根据左右节点可知道所有子节点的信息，故一个Tree只要知道root节点即可。
故Node定义为：

    public class BiNode<T>{
        private T data;
        private BiNode left;
        private BiNode right;

        public BiNode(T data) {
            this.data = data;
        }

        public T getData() {
            return data;
        }

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

        public BiNode getLeft() {
            return left;
        }

        public void setLeft(BiNode left) {
            this.left = left;
        }

        public BiNode getRight() {
            return right;
        }

        public void setRight(BiNode right) {
            this.right = right;
        }
    }

Tree的定义

public class BiTree {

    private BiNode<Integer> root;

    private void createBiTree(int[] nums) {
        if (nums==null||nums.length<1) {
            return;
        }

        root = new BiNode<Integer>(nums[0]);
        BiNode<Integer> parent = null;
        //用于确定数组元素添加为左还是右
        boolean isLeft = true;
        LinkedList<BiNode<Integer>> nodeList = new LinkedList<BiNode<Integer>>();
        nodeList.addLast(root);
        for (int i = 1;i<nums.length;i++) {
            BiNode<Integer> current = new BiNode<Integer>(nums[i]);
            //先存入list中
            nodeList.addLast(current);

            //从队列头部取parent，当右子树添加完毕后删除头部元素
            if (isLeft) {
                parent = nodeList.getFirst();
            } else {
                parent = nodeList.removeFirst();
            }

            if (isLeft) {
                parent.setLeft(current);
                isLeft = false;
            } else {
                parent.setRight(current);
                isLeft = true;
            }

        }

    }

    /**
     * BiTree递归先序遍历
     */
    private void preSearch() {
        System.out.println("BiTree递归先序遍历");
        preSearch(root);
    }

    private void preSearch(BiNode<Integer> node) {

        visitNode(node);
        if (node.getLeft()!=null) {
            preSearch(node.getLeft());
        }
        if (node.getRight()!=null) {
            preSearch(node.getRight());
        }
    }

    /**
     * BiTree非递归先序遍历
     * 采用堆栈先进后出
     */
    private void preSearchNew(){
        System.out.println();
        System.out.println("BiTree非递归先序遍历");
        preSearchNew(root);
    }

    private void preSearchNew(BiNode<Integer> node) {
        Stack<BiNode<Integer>> statck = new Stack<BiNode<Integer>>();
        statck.push(node);
        BiNode<Integer> current;
        while (!statck.isEmpty()) {
            current = statck.pop();
            visitNode(current);

            if (current.getRight()!=null) {
                statck.push(current.getRight());
            }
            if (current.getLeft()!=null) {
                statck.push(current.getLeft());
            }
        }

    }


    private void visitNode(BiNode<Integer> node) {
        System.out.print(node.getData());
    }
   }

测试用例

public static void main(String[] args) {
        BiTree biTree = new BiTree();
        biTree.createBiTree(new int[]{1,2,3,4,5,6,7,8});
        biTree.preSearch();
        biTree.preSearchNew();
    }

递归遍历

先序递归遍历时，先输出父节点，先递归输出左子节点，直到左子节点为空时输出右子节点，右子节点为空时，输出父节点的右节点。

非递归遍历

采用Stack，首先将父节点压入栈，判断栈不为空时，pop出父节点，输出父节点，再压入右节点，再压入左子节点，pop出左子节点，再压入左子节点的右子节点和左子节点，直到左子节点全部入栈，在pop出右子节点。