【數據結構】遍歷二叉樹

遍歷二叉樹

        遍歷二叉樹指的是按某種規律依次訪問二叉樹的每一個節點，對二叉樹的遍歷過程就是將非線性結構的二叉樹中的節點排列在一個線性序列上的過程。

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());
    }
}