二叉树的遍历

二叉树的遍历

先序遍历

所有父节点先于左右子树的顺序，父亲 -> 左子树（递归） -> 右子树（递归）

后续遍历

所有父节点后于左右子树的顺序, 左子树（递归） -> 右子树（递归） -> 父亲

中序遍历

父节点的在左右子树的中间访问，左子树（递归）-> 父亲 -> 右子树（递归）

层序遍历

借助一个双端队列实现，比如有如下的二叉树

将根节点加入队列

不断地取出队列中第一个元素加入list, 并将当前节点的的两个孩子加入队列 ,

循环直到队列为空，则遍历结束

最终遍历结果为list， 工具双端队列queue:

list :		1	12	123	1234	12345	123456	1234567	12345678	123456789
queue:	1	23	345	4567	56789	6789	789	89	9

代码如下

package com.susq.algorithm.tree;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

/**
 * @author susq
 * @since 2017-12-14-14:56
 */
public class BinTree<E> {

    private TreeNode root;

    public BinTree() {
        this.root = new TreeNode();
    }

    public BinTree(E data) {
        this.root = new TreeNode(data);
    }

    /**
     * 为指定节点添加新节点
     *
     * @param parent 父节点
     * @param data   新的数据
     * @param isLeft 是否为左孩子
     * @return 新的节点
     */
    public TreeNode addNode(TreeNode parent, E data, boolean isLeft) {
        if (parent == null) {
            throw new RuntimeException("节点为null, 无法添加子节点");
        }
        if (isLeft && parent.left != null) {
            throw new RuntimeException(parent + "已经有左子节点，无法继续添加");
        }
        if (!isLeft && parent.right != null) {
            throw new RuntimeException(parent + "已经有右子节点，无法继续添加");
        }
        TreeNode newNode = new TreeNode(data);
        if (isLeft) {
            parent.left = newNode;
        } else {
            parent.right = newNode;
        }
        newNode.parent = parent;
        return newNode;
    }

    public boolean empty() {
        return root.data == null;
    }

    public TreeNode getRoot() {
        if (empty()) {
            throw new RuntimeException("树为空");
        }
        return root;
    }

    public E parent(TreeNode node) {
        if (node == null) {
            throw new RuntimeException("节点为空，没有父节点");
        }
        return (E) node.parent.data;
    }

    public E leftChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException("节点为空，没有孩子");
        }
        return parent.left == null ? null : (E) parent.left;
    }

    public E rightChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException("节点为空，没有孩子");
        }
        return parent.right == null ? null : (E) parent.right;
    }

    public int deep() {
        return deep(root);
    }

    private int deep(TreeNode node) {
        if (node == null) {
            return 0;
        }
        if (node.left == null && node.right == null) {
            return 1;
        } else {
            int leftDeep = deep(node.left);
            int rightDeep = deep(node.right);
            int max = leftDeep > rightDeep ? leftDeep : rightDeep;
            return max + 1;
        }
    }

    /**
     * 实现先序遍历
     *
     * @return
     */
    public List<TreeNode> preIterator() {
        return preIterator(root);
    }

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

    /**
     * 实现中序遍历
     *
     * @return
     */
    public List<TreeNode> inIterator() {
        return inIterator(root);
    }

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

    /**
     * 实现后续遍历
     *
     * @return
     */
    public List<TreeNode> psotIterator() {
        return postIterator(root);
    }

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

    /**
     * 实现广度优先遍历，又称为按层遍历
     * 借助一个双端队列
     *
     * @return
     */
    public List<TreeNode> breadthFirst() {
        Queue<TreeNode> queue = new ArrayDeque<>(); //ArrayDeque数双端队列实现类
        List<TreeNode> list = new ArrayList<>();
        if (root != null) {
            queue.offer(root); // offer：添加一个元素并返回true,如果队列已满，则返回false
        }
        // while 循环中，移除队列的第一个节点，并且将这个节点左子节点、右子节点加入队列，
        // 每次取出队列中元素的时候，把它的所有孩子加入队列末尾，在二叉树中就是父节点遍历过后，把下层的节点加入队列。
        while (!queue.isEmpty()) {
            list.add(queue.peek()); // peek:返回队列头部的元素,如果队列为空，则返回null
            TreeNode p = queue.poll(); //poll：移除并返问队列头部的元素, 如果队列为空，则返回null
            if (p.left != null) {
                queue.offer(p.left);
            }
            if (p.right != null) {
                queue.offer(p.right);
            }
        }
        return list;
    }

    /**
     * 树的节点
     */
    public static class TreeNode {
        Object data;
        TreeNode left;
        TreeNode right;
        TreeNode parent;

        public TreeNode() {
        }

        public TreeNode(Object data) {
            this.data = data;
        }

        public TreeNode(Object data, TreeNode left, TreeNode right, TreeNode parent) {
            this.data = data;
            this.left = left;
            this.right = right;
            this.parent = parent;
        }
    }
}