【数据结构】遍历二叉树

遍历二叉树

        遍历二叉树指的是按某种规律依次访问二叉树的每一个节点，对二叉树的遍历过程就是将非线性结构的二叉树中的节点排列在一个线性序列上的过程。

public class ThreeLinkBinTree<E> {

    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;
        }
    }
    private TreeNode root;
    // 以默认构造器建立二叉树
    public ThreeLinkBinTree() {
        this.root = new TreeNode();
    }
    // 以指定根元素建立二叉树
    public ThreeLinkBinTree(E data) {
        this.root = new TreeNode(data);
    }
    /**
     * 为指定节点添加子节点
     * @param parent 须要添加子节点的父节点的索引
     * @param data 新子节点的数据
     * @param left 是否为左节点
     * @return 新增的节点
     */
    public TreeNode addNode(TreeNode parent, E data, boolean left) {
        if (parent == null) {
            throw new RuntimeException(parent + "节点为空，没法添加子节点");
        }
        if (left && parent.left != null) {
            throw new RuntimeException(parent + "节点已有左子节点，没法添加左子节点");
        }
        if (!left && parent.right != null) {
            throw new RuntimeException(parent + "节点已有右子节点，没法添加右子节点");
        }
        TreeNode newNode = new TreeNode(data);
        if (left) {
            parent.left = newNode;
        } else {
            parent.right = newNode;
        }
        newNode.parent = parent;
        return newNode;
    }
    // 判断二叉树是否为空
    public boolean empty() {
        // 根据根元素来判断二叉树是否为空
        return root.data == null;
    }
    // 返回根节点
    public TreeNode root() {
        if (empty()) {
            throw new RuntimeException("根节点为空");
        }
        return root;
    }
    // 返回指定节点（非根节点）的父节点
    public E parent(TreeNode node) {
        if (node == null) {
            throw new RuntimeException(node + "节点为空，没法返回其父节点");
        }
        return (E)node.parent.data;
    }
    // 返回指定节点（非叶子）的左子节点。当左子节点不存在时返回null
    public E leftChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException(parent + "节点为空，无左子节点");
        }
        return parent.left == null? null : (E)parent.left.data;
    }
    // 返回指定节点（非叶子）的右子节点。当右子节点存在时返回null
    public E rightChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException(parent + "节点为空，无右子节点");
        }
        return parent.right == null? null : (E)parent.right.data;
    }
    // 返回该二叉树的深度
    public int deep() {
        // 获取该树的深度
        return deep(root);
    }
    // 递归方法：每颗子树的深度为其全部子树的最大深度 + 1
    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;
        }
    }
    // 实现先序遍历
    public List<TreeNode> preIterator() {
        return preIterator(root);
    }
    private List<TreeNode> preIterator(TreeNode node) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        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<TreeNode> inIterator() {
        return inIterator(root);
    }
    private List<TreeNode> inIterator(TreeNode node) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        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<TreeNode> postIterator() {
        return postIterator(root);
    }
    // 实现后序遍历
    private List<TreeNode> postIterator(TreeNode node) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        if (node.left != null) {
            list.addAll(postIterator(node.left));
        }
        if (node.right != null) {
            list.addAll(postIterator(node.right));
        }
        list.add(node);
        return list;
    }
    // 广度优先遍历
    public List<TreeNode> breadthFirst() {
        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
        List<TreeNode> list = new ArrayList<TreeNode>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            list.add(queue.peek());
            TreeNode node = queue.poll();
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return list;
    }
}

public class ThreeLinkBinTreeTest {
    public static void main(String[] args) {
        ThreeLinkBinTree<String> binTree = new ThreeLinkBinTree("根节点");
        ThreeLinkBinTree.TreeNode tn1 = binTree.addNode(binTree.root(), "二左", true);
        ThreeLinkBinTree.TreeNode tn2 = binTree.addNode(binTree.root(), "二右", false);
        ThreeLinkBinTree.TreeNode tn3 = binTree.addNode(tn1, "三左", true);
        ThreeLinkBinTree.TreeNode tn4 = binTree.addNode(tn1, "三右", false);
        ThreeLinkBinTree.TreeNode tn5 = binTree.addNode(tn3, "四右", false);
        ThreeLinkBinTree.TreeNode tn6 = binTree.addNode(tn5, "五左", true);
        ThreeLinkBinTree.TreeNode tn7 = binTree.addNode(tn5, "五右", false);
        System.out.println("【前序遍历】：" + binTree.preIterator());
        System.out.println("【中序遍历】：" + binTree.inIterator());
        System.out.println("【后序遍历】：" + binTree.postIterator());
        System.out.println("【广度优先遍历】：" + binTree.breadthFirst());
    }
}