Java中二叉樹存儲結構實現

一、二叉樹

二叉樹指的是每個節點最多只能有兩個子樹的有序樹。通常左邊的子樹被稱為“左子樹”（left subtree），右邊的子樹被稱為右子樹。

二叉樹的每個節點最多只有2棵子樹，二叉樹的子樹次序不能顛倒。

二、順序存儲二叉樹的實現

package com.ietree.basic.datastructure.tree.binarytree;

/**
 * Created by ietree
 * 2017/5/1
 */
public class ArrayBinTree<T> {

    // 使用數組來記錄該樹的所有節點
    private Object[] datas;
    private int DEFAULT_DEEP = 8;
    // 保存該樹的深度
    private int deep;
    private int arraySize;

    // 以默認的深度創建二叉樹
    public ArrayBinTree() {
        this.deep = DEFAULT_DEEP;
        this.arraySize = (int) (Math.pow(2, deep) - 1);
        datas = new Object[arraySize];
    }

    // 以指定深度創建二叉樹
    public ArrayBinTree(int deep) {
        this.deep = deep;
        this.arraySize = (int) Math.pow(2, deep) - 1;
        datas = new Object[arraySize];
    }

    // 以指定深度、指定節點創建二叉樹
    public ArrayBinTree(int deep, T data) {
        this.deep = deep;
        this.arraySize = (int) Math.pow(2, deep) - 1;
        datas = new Object[arraySize];
        datas[0] = data;
    }

    /**
     * 為指定節點添加子節點
     *
     * @param index 需要添加子節點的父節點的索引
     * @param data  新子節點的數據
     * @param left  是否為左節點
     */
    public void add(int index, T data, boolean left) {
        if (datas[index] == null) {
            throw new RuntimeException(index + "處節點為空，無法添加子節點");
        }
        if (2 * index + 1 >= arraySize) {
            throw new RuntimeException("樹底層的數組已滿，樹越界異常");
        }
        // 添加左子節點
        if (left) {
            datas[2 * index + 1] = data;
        } else {
            datas[2 * index + 2] = data;
        }
    }

    // 判斷二叉樹是否為空
    public boolean empty() {
        // 根據根元素判斷二叉樹是否為空
        return datas[0] == null;
    }

    // 返回根節點
    public T root() {
        return (T) datas[0];
    }

    // 返回指定節點（非根結點）的父節點
    public T parent(int index) {
        return (T) datas[(index - 1) / 2];
    }

    // 返回指定節點（非葉子）的左子節點，當左子節點不存在時返回null
    public T left(int index) {
        if (2 * index + 1 >= arraySize) {
            throw new RuntimeException("該節點為葉子節點，無子節點");
        }
        return (T) datas[index * 2 + 1];
    }

    // 返回指定節點（非葉子）的右子節點，當右子節點不存在時返回null
    public T right(int index) {
        if (2 * index + 1 >= arraySize) {
            throw new RuntimeException("該節點為葉子節點，無子節點");
        }
        return (T) datas[index * 2 + 2];
    }

    // 返回該二叉樹的深度
    public int deep(int index) {
        return deep;
    }

    // 返回指定節點的位置
    public int pos(T data) {
        // 該循環實際上就是按廣度遍歷來搜索每個節點
        for (int i = 0; i < arraySize; i++) {
            if (datas[i].equals(data)) {
                return i;
            }

        }
        return -1;
    }

    public String toString() {
        return java.util.Arrays.toString(datas);
    }

}

測試類：

package com.ietree.basic.datastructure.tree.binarytree;

/**
 * Created by ietree
 * 2017/5/1
 */
public class ArrayBinTreeTest {

    public static void main(String[] args) {

        ArrayBinTree<String> binTree = new ArrayBinTree<String>(4, "根");
        binTree.add(0, "第二層右子節點", false);
        binTree.add(2, "第三層右子節點", false);
        binTree.add(6, "第四層右子節點", false);
        System.out.println(binTree);
        
    }

}

程序輸出：

[根, null, 第二層右子節點, null, null, null, 第三層右子節點, null, null, null, null, null, null, null, 第四層右子節點]

三、二叉樹的二叉鏈表存儲

 二叉鏈表存儲的思想是讓每個節點都能“記住”它的左、右兩個子節點。為每個節點增加left、right兩個指針，分別引用該節點的左、右兩個子節點。

package com.ietree.basic.datastructure.tree.binarytree;

/**
 * Created by ietree
 * 2017/5/1
 */
public class TwoLinkBinTree<E> {

    public static class TreeNode {

        Object data;
        TreeNode left;
        TreeNode right;

        public TreeNode() {

        }

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

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

    }

    private TreeNode root;

    // 以默認的構造器創建二叉樹
    public TwoLinkBinTree() {
        this.root = new TreeNode();
    }

    // 以指定根元素創建二叉樹
    public TwoLinkBinTree(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(parent + "節點為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) {
            // 讓父節點的left引用指向新節點
            parent.left = newNode;
        } else {
            // 讓父節點的left引用指向新節點
            parent.right = newNode;
        }
        return newNode;
    }

    // 判斷二叉樹是否為空
    public boolean empty() {
        // 根據元素判斷二叉樹是否為空
        return root.data == null;
    }

    // 返回根節點
    public TreeNode root() {
        if (empty()) {
            throw new RuntimeException("樹為空，無法訪問根節點");
        }
        return root;
    }

    // 返回指定節點（非根節點）的父節點
    public E parent(TreeNode node) {
        // 對於二叉樹鏈表存儲法，如果要訪問指定節點的父節點必須遍歷二叉樹
        return null;
    }

    // 返回指定節點（非葉子）的左子節點，當左子節點不存在時返回null
    public E leftChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException(parent + "節點為null，無法添加子節點");
        }
        return parent.left == null ? null : (E) parent.left.data;
    }

    // 返回指定節點（非葉子）的右子節點，當右子節點不存在時返回null
    public E rightChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException(parent + "節點為null，無法添加子節點");
        }
        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;
            // 返回其左右子樹中較大的深度 + 1
            return max + 1;
        }

    }

}

測試類：

package com.ietree.basic.datastructure.tree.binarytree;

/**
 * Created by ietree
 * 2017/5/1
 */
public class TwoLinkBinTreeTest {

    public static void main(String[] args) {

        TwoLinkBinTree<String> binTree = new TwoLinkBinTree<String>("根節點");
        // 依次添加節點
        TwoLinkBinTree.TreeNode tn1 = binTree.addNode(binTree.root(), "第二層左節點", true);
        TwoLinkBinTree.TreeNode tn2 = binTree.addNode(binTree.root(), "第二層右節點", false);
        TwoLinkBinTree.TreeNode tn3 = binTree.addNode(tn2, "第三層左節點", true);
        TwoLinkBinTree.TreeNode tn4 = binTree.addNode(tn2, "第三層右節點", false);
        TwoLinkBinTree.TreeNode tn5 = binTree.addNode(tn3, "第四層左節點", true);

        System.out.println("tn2的左子節點：" + binTree.leftChild(tn2));
        System.out.println("tn2的右子節點：" + binTree.rightChild(tn2));
        System.out.println(binTree.deep());

    }

}

程序輸出：

tn2的左子節點：第三層左節點
tn2的右子節點：第三層右節點
4

四、二叉樹的三叉鏈表存儲

 三叉鏈表存儲方式是對二叉鏈表的一種改進，通過為樹節點增加一個parent引用，可以讓每個節點都能非常方便的訪問其父節點，三叉鏈表存儲的二叉樹即可方便地向下訪問節點，也可方便地向上訪問節點。

package com.ietree.basic.datastructure.tree.binarytree;

/**
 * Created by ietree
 * 2017/5/1
 */
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 isLeft 是否為左節點
     * @return 新增的節點
     */
    public TreeNode addNode(TreeNode parent, E data, boolean isLeft) {

        if (parent == null) {
            throw new RuntimeException(parent + "節點為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) {
            // 讓父節點的left引用指向新節點
            parent.left = newNode;
        } else {
            // 讓父節點的left引用指向新節點
            parent.right = newNode;
        }
        // 讓新節點的parent引用到parent節點
        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("節點為null，無法訪問其父節點");
        }
        return (E) node.parent.data;
    }

    // 返回指定節點（非葉子）的左子節點，當左子節點不存在時返回null
    public E leftChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException(parent + "節點為null，無法添加子節點");
        }
        return parent.left == null ? null : (E) parent.left.data;
    }

    // 返回指定節點（非葉子）的右子節點，當右子節點不存在時返回null
    public E rightChild(TreeNode parent) {
        if (parent == null) {
            throw new RuntimeException(parent + "節點為null，無法添加子節點");
        }
        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;
            // 返回其左右子樹中較大的深度 + 1
            return max + 1;
        }

    }

}

測試類：

package com.ietree.basic.datastructure.tree.binarytree;

/**
 * Created by ietree
 * 2017/5/1
 */
public class ThreeLinkBinTreeTest {

    public static void main(String[] args) {

        ThreeLinkBinTree<String> binTree = new ThreeLinkBinTree<String>("根節點");
        // 依次添加節點
        ThreeLinkBinTree.TreeNode tn1 = binTree.addNode(binTree.root(), "第二層左節點", true);
        ThreeLinkBinTree.TreeNode tn2 = binTree.addNode(binTree.root(), "第二層右節點", false);
        ThreeLinkBinTree.TreeNode tn3 = binTree.addNode(tn2, "第三層左節點", true);
        ThreeLinkBinTree.TreeNode tn4 = binTree.addNode(tn2, "第三層右節點", false);
        ThreeLinkBinTree.TreeNode tn5 = binTree.addNode(tn3, "第四層左節點", true);

        System.out.println("tn2的左子節點：" + binTree.leftChild(tn2));
        System.out.println("tn2的右子節點：" + binTree.rightChild(tn2));
        System.out.println(binTree.deep());

    }

}

程序輸出：

tn2的左子節點：第三層左節點
tn2的右子節點：第三層右節點
4