数据结构-二叉树遍历

采用顺序结构来保存二叉树，程序遍历底层数组即可。

采用链表保存二叉树：

1、深度优先遍历：先访问到树中最深层次的节点

    L：左子树    D：根    R：右子树

    1）先（前）序遍历二叉树    DLR

    2）中序遍历二叉树              LDR

    3）后序遍历二叉树              LRD

2、广度优先遍历：逐层访问每层的节点，也叫按层遍历

//先序遍历
    public List preIterator() {
        return preIterator(root);
    }

    private List preIterator(TreeNode node) {
        List list = new ArrayList<>();
        //处理根节点
        list.add(node);
        //递归处理左子树
        if (node.left != null) {
            list.addAll(preIterator(node.left));
        }

        //递归处理右子树
        if (node.right != null) {
            list.addAll(preIterator(node.right));
        }
        return list;
    }

    //中序遍历
    public List inIterator() {
        return inIterator(root);
    }

    private List inIterator(TreeNode node) {
        List list = new ArrayList<>();
        if (node.left != null) {
            list.addAll(inIterator(node.left));
        }
        list.add(node);
        if (node.right != null) {
            list.addAll(inIterator(node.right));
        }
        return list;
    }

    //后序遍历
    public List postIterator() {
        return postIterator(root);
    }

    private List postIterator(TreeNode node) {
        List list = new ArrayList<>();
        if (node.left != null) {
            list.addAll(inIterator(node.left));
        }
        if (node.right != null) {
            list.addAll(inIterator(node.right));
        }
        list.add(node);
        return list;
    }

    //广度优先遍历
    public List breadthFirst() {
        Queue queue = new ArrayDeque<>();
        List list = new ArrayList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            list.add(queue.peek());
            TreeNode p = queue.poll();
            if (p.left != null) {
                queue.offer(p.left);
            }
            if (p.right != null) {
                queue.offer(p.right);
            }
        }
        return list;
    }