二叉树的创建与遍历

二叉树创建

创建根据数组，值为0代表空节点

    private static Node createTree(int[] data, int index) {
        if (index >= data.length || data[index] == 0) {
            return null;
        }
        Node node = new Node();
        node.setValue(data[index]);
        node.setLeftChild(createTree(data, 2 * index + 1));
        node.setRightChild(createTree(data, 2 * index + 2));
        return node;
    }

createTree是创建以index索引代表节点为root的树，所以我们首先创建节点赋上对应值，然后设置左右子树，通过递归，最后得到二叉树。

二叉树的深度优先遍历的递归算法

深度优先遍历还分为先序、中序、后序。以先序为例，先序就是先访问根节点，再先序遍历左子树，然后先序遍历右子树，很明显可以递归完成。

    /**
     * 先序
     * @param root
     */
    private static void preOrder(Node root) {
        if (root != null) {
            System.out.println(root.getValue() + "");
            preOrder(root.getLeftChild());
            preOrder(root.getRightChild());
        }
    }

    /**
     * 中序
     * @param root
     */
    private static void inOrder(Node root) {
        if (root != null) {
            preOrder(root.getLeftChild());
            System.out.println(root.getValue() + "");
            preOrder(root.getRightChild());
        }
    }

    /**
     * 后序 
     * @param root
     */
    private static void postOrder(Node root) {
        if (root != null) {
            preOrder(root.getLeftChild());
            preOrder(root.getRightChild());
            System.out.println(root.getValue() + "");
        }
    }

二叉树的深度优先遍历的非递归算法

先序

非递归方法我们使用栈来实现

    /**
     * 先序非递归
     * @param node
     */
    private static void pre(Node node) {
        if (node == null) {
            return;
        }
        ArrayDeque<Node> stack = new ArrayDeque<>();
        stack.push(node);
        while (!stack.isEmpty()) {
            Node n = stack.pop();
            System.out.println(n.getValue() + "");
            if (n.getRightChild() != null) {
                stack.push(n.getRightChild());
            }
            if (n.getLeftChild() != null) {
                stack.push(n.getLeftChild());
            }
        }
    }

首先root入栈，然后循环访问栈顶元素并出栈，接下来将左右子节点入栈，入栈顺序要是先右后左。

二叉树的广度优先遍历

我们可以通过一个队列来保存访问过的节点的左右子节点，然后删除访问过的节点，直到队列为空

    private static void layer(Node root) {
        if (root == null) {
            return;
        }
        List<Node> nodeQueue = new ArrayList<Node>();
        nodeQueue.add(root);
        while (nodeQueue.size() != 0) {
            Node node = nodeQueue.remove(0);
            System.out.println(node.getValue() + "");
            if (node.getLeftChild() != null) {
                nodeQueue.add(node.getLeftChild());
            }
            if (node.getRightChild() != null) {
                nodeQueue.add(node.getRightChild());
            }
        }
    }