【數據結構】二叉樹

一、二叉樹介紹　　

　　簡單地理解，滿足以下兩個條件的樹就是二叉樹：

1. 本身是有序樹；

2. 樹中包含的各個節點的度不能超過 2，即只能是 0、1 或者 2；

二、二叉樹的性質

　　經過前人的總結，二叉樹具有以下幾個性質：

1. 二叉樹中，第 i 層最多有 2^i-1 個結點。

2. 如果二叉樹的深度為 K，那么此二叉樹最多有 2^K-1 個結點。

3. 二叉樹中，終端結點數（葉子結點數）為 n₀，度為 2 的結點數為 n₂，則 n₀=n₂+1。　　

　　性質 3 的計算方法為：對於一個二叉樹來說，除了度為 0 的葉子結點和度為 2 的結點，剩下的就是度為 1 的結點（設為 n₁），那么總結點 n=n₀+n₁+n₂。同時，對於每一個結點來說都是由其父結點分支表示的，假設樹中分枝數為 B，那么總結點數 n=B+1。而分枝數是可以通過 n₁ 和 n₂ 表示的，即 B=n₁+2*n₂。所以，n 用另外一種方式表示為 n=n₁+2*n₂+1。

　　兩種方式得到的 n 值組成一個方程組，就可以得出 n₀=n₂+1。

　　二叉樹還可以繼續分類，衍生出滿二叉樹和完全二叉樹。

三、滿二叉樹

　　如果二叉樹中除了葉子結點，每個結點的度都為 2，則此二叉樹稱為滿二叉樹。

　　

　　如圖 2 所示就是一棵滿二叉樹。

　　滿二叉樹除了滿足普通二叉樹的性質，還具有以下性質：

• 滿二叉樹中第 i 層的節點數為 2^n-1 個。

• 深度為 k 的滿二叉樹必有 2^k-1 個節點 ，葉子數為 2^k-1。

• 滿二叉樹中不存在度為 1 的節點，每一個分支點中都兩棵深度相同的子樹，且葉子節點都在最底層。

• 具有 n 個節點的滿二叉樹的深度為 log₂(n+1)。

四、完全二叉樹

 　　如果二叉樹中除去最后一層節點為滿二叉樹，且最后一層的結點依次從左到右分布，則此二叉樹被稱為完全二叉樹。 

　　

 　　如圖 3a) 所示是一棵完全二叉樹，圖 3b) 由於最后一層的節點沒有按照從左向右分布，因此只能算作是普通的二叉樹。

　　完全二叉樹除了具有普通二叉樹的性質，它自身也具有一些獨特的性質，比如說，n 個結點的完全二叉樹的深度為 ⌊log₂n⌋+1。　　

　　⌊log₂n⌋ 表示取小於 log₂n 的最大整數。例如，⌊log₂4⌋ = 2，而 ⌊log₂5⌋ 結果也是 2。　　

　　對於任意一個完全二叉樹來說，如果將含有的結點按照層次從左到右依次標號（如圖 3a)），對於任意一個結點 i ，完全二叉樹還有以下幾個結論成立：

1. 當 i>1 時，父親結點為結點 [i/2] 。（i=1 時，表示的是根結點，無父親結點）

2. 如果 2*i>n（總結點的個數） ，則結點 i 肯定沒有左孩子（為葉子結點）；否則其左孩子是結點 2*i 。

3. 如果 2*i+1>n ，則結點 i 肯定沒有右孩子；否則右孩子是結點 2*i+1 。

五、樹的存儲結構

 　　二叉樹的存儲結構有兩種，分別為順序存儲和鏈式存儲。

1 、順序存儲

　　二叉樹的順序存儲，指的是使用順序表（數組）存儲二叉樹。需要注意的是，順序存儲只適用於完全二叉樹。換句話說，只有完全二叉樹才可以使用順序表存儲。因此，如果我們想順序存儲普通二叉樹，需要提前將普通二叉樹轉化為完全二叉樹。

　　有讀者會說，滿二叉樹也可以使用順序存儲。要知道，滿二叉樹也是完全二叉樹，因為它滿足完全二叉樹的所有特征。

　　普通二叉樹轉完全二叉樹的方法很簡單，只需給二叉樹額外添加一些節點，將其"拼湊"成完全二叉樹即可。如圖 1 所示：

 　　　　

　　圖 1 中，左側是普通二叉樹，右側是轉化后的完全（滿）二叉樹。　　

　　解決了二叉樹的轉化問題，接下來學習如何順序存儲完全（滿）二叉樹。

　　完全二叉樹的順序存儲，僅需從根節點開始，按照層次依次將樹中節點存儲到數組即可。

 　　　　　　--->　　　　  

　　存儲由普通二叉樹轉化來的完全二叉樹也是如此

　　　　　　--->　　　　

 

非常重要

 

　　完全二叉樹具有這樣的性質，將樹中節點按照層次並從左到右依次標號（0,1,2,3,...），

　　若節點 i 有左右孩子，則其左孩子節點為 2 * i + 1，右孩子節點為 2 * i+2。

　　此性質可用於還原數組中存儲的完全二叉樹

2、鏈式存儲

　　　　　　--->　　　　

　　如圖 1 所示，此為一棵普通的二叉樹，若將其采用鏈式存儲，則只需從樹的根節點開始，將各個節點及其左右孩子使用鏈表存儲即可。

　　因此，圖 1 對應的鏈式存儲結構如圖 2 所示：

　　 由圖 2 可知，采用鏈式存儲二叉樹時，其節點結構由 3 部分構成（如圖 3 所示）：

• 指向左孩子節點的指針（Lchild）；

• 節點存儲的數據（data）；

• 指向右孩子節點的指針（Rchild）

　　

六、樹的遍歷

• 前序遍歷: 先輸出父節點， 再遍歷左子樹和右子樹

• 中序遍歷: 先遍歷左子樹， 再輸出父節點， 再遍歷右子樹

• 后序遍歷: 先遍歷左子樹， 再遍歷右子樹， 最后輸出父節點

　　看輸出父節點的順序，就確定是前序，中序還是后序

　　示例代碼如下：　　

public class BinaryTree {


    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        TreeNode node = binaryTree.initTree();
        List<Integer> preList = binaryTree.preOrder(node);
        System.out.println("preList = " + preList);
        List<Integer> midOrder = binaryTree.midOrder(node);
        System.out.println("midOrder = " + midOrder);
        List<Integer> afterOrder = binaryTree.afterOrder(node);
        System.out.println("afterOrder = " + afterOrder);
    }

    // 先遍歷左子樹，再遍歷右子樹，最后輸出父節點
    public List<Integer> afterOrder(TreeNode node) {
        List<Integer> list = new ArrayList<>();
        if (node != null) {
            list.addAll(afterOrder(node.left));
            list.addAll(afterOrder(node.right));
            list.add(node.val);
        }
        return list;
    }

    // 先遍歷左子樹，再輸出父節點，再遍歷右子樹
    public List<Integer> midOrder(TreeNode node) {
        List<Integer> list = new ArrayList<>();
        if (node != null) {
            list.addAll(midOrder(node.left));
            list.add(node.val);
            list.addAll(midOrder(node.right));
        }
        return list;
    }

    // 先輸出父節點，再遍歷左子樹和右子樹
    public List<Integer> preOrder(TreeNode node) {
        List<Integer> list = new ArrayList<>();
        if (node != null) {
            list.add(node.val);
            list.addAll(preOrder(node.left));
            list.addAll(preOrder(node.right));
        }
        return list;
    }

    private TreeNode initTree() {
        //      1
        //   2      3
        // 4   5  6    7
        TreeNode node2 = new TreeNode(2, new TreeNode(4), new TreeNode(5));
        TreeNode node3 = new TreeNode(3, new TreeNode(6), new TreeNode(7));
        return new TreeNode(1, node2, node3);
    }


    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

 　　順序存儲二叉樹的遍歷

　　示例代碼如下：

public class ArrBinaryTree {

    public List<Integer> preOrder(int[] arr) {
        return preOrder(arr, 0);
    }

    // 前序遍歷
    private List<Integer> preOrder(int[] arr, int index) {
        List<Integer> list = new ArrayList<>();
        if(index < arr.length) {
            list.add(arr[index]);
            list.addAll(preOrder(arr, 2 * index + 1));
            list.addAll(preOrder(arr, 2 * index + 2));
        }
        return list;
    }

    public List<Integer> midOrder(int[] arr) {
        return midOrder(arr, 0);
    }

    // 中序遍歷
    private List<Integer> midOrder(int[] arr, int index) {
        List<Integer> list = new ArrayList<>();
        if(index < arr.length) {
            list.addAll(midOrder(arr, 2 * index + 1));
            list.add(arr[index]);
            list.addAll(midOrder(arr, 2 * index + 2));
        }
        return list;
    }

    // 前序遍歷轉化
    public TreeNode preOrderConvert(int[] arr) {
        return preOrderConvert(arr, 0);
    }

    private TreeNode preOrderConvert(int[] arr, int index) {
        if(index < arr.length) {
            TreeNode treeNode = new TreeNode(arr[index]);
            treeNode.left = preOrderConvert(arr, 2 * index + 1);
            treeNode.right = preOrderConvert(arr, 2 * index + 2);
            return treeNode;
        }
        return null;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        ArrBinaryTree arrBinaryTree = new ArrBinaryTree();
        // 前序遍歷
        List<Integer> proList = arrBinaryTree.preOrder(arr);
        System.out.println("proList = " + proList);
        // 中序遍歷
        List<Integer> midList = arrBinaryTree.midOrder(arr);
        System.out.println("midList = " + midList);

        // 轉化成樹，前序遍歷轉化
        TreeNode treeNode = arrBinaryTree.preOrderConvert(arr);
        System.out.println("treeNode = " + treeNode);
    }

    static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

七、線索化二叉樹

　　將數列 {1, 3, 6, 8, 10, 14 } 構建成一顆二叉樹，當我們對這顆二叉樹進行中序遍歷時， 輸出數列為 {8, 3, 10, 1, 6, 14 }

　　但是 6, 8, 10, 14 這幾個節點的左右指針，並沒有完全的利用上，如果我們希望充分的利用 各個節點的左右指針， 讓各個節點可以指向自己的前后節點，怎么辦?

　　解決方案：線索二叉樹

　　

線索二叉樹基本介紹

• n 個結點的二叉鏈表中含有 n+1 【公式 2n-(n-1)=n+1】 個空指針域。 利用二叉鏈表中的空指針域， 存放指向該結點在某種遍歷次序下的前驅和后繼結點的指針（這種附加的指針稱為"線索"）

• 這種加上了線索的二叉鏈表稱為線索鏈表， 相應的二叉樹稱為線索二叉樹(Threaded BinaryTree)。

• 根據線索性質的不同， 線索二叉樹可分為前序線索二叉樹、 中序線索二叉樹和后序線索二叉樹三種

• 前驅結點和后繼節點：

  • 一個結點的前一個結點， 稱為前驅結點
  • 一個結點的后一個結點， 稱為后繼結點

• 當我們對二叉樹進行中序遍歷時， 得到的數列為 {8, 3, 10, 1, 6, 14 }

  • 那么 8 節點的前驅結點為 null ，8 和后驅節點為 3

  • 那么 3 節點的前驅結點為 8 ，3 和后驅節點為 10

  • 以此類推…　　

　　

　　代碼實現

public class ThreadBinaryTree {

    // 最后處理過的節點，即當前處理節點的前一個處理節點
    private TreeNode preNode;

    // 中序線索化
    public void midOrderThreadedNodes(TreeNode node) {
        if (node != null) {
            // 1、先線索化左子樹
            midOrderThreadedNodes(node.left);
            // 2、線索化當前節點
            if (node.left == null) {
                node.leftType = 1;
                node.left = preNode;
            }
            if (preNode != null && preNode.right == null) {
                preNode.rightType = 1;
                preNode.right = node;
            }
            // 更新preNode節點
            preNode = node;
            // 3、再線索化右子樹
            midOrderThreadedNodes(node.right);
        }
    }

    // 遍歷中序線索化二叉樹
    public List<Integer> midOrderThreadList(TreeNode treeNode) {
        List<Integer> list = new ArrayList<>();
        // 找到leftType = 1 && left == null 的節點
        // 這個節點就是第一個線索化的節點
        TreeNode node = treeNode;
        while (node != null) {

            while (node.leftType == 0) {
                node = node.left;
            }

            list.add(node.val);

            while (node.rightType == 1) {
                node = node.right;
                list.add(node.val);
            }

            node = node.right;
        }
        return list;
    }

    public List<Integer> midOrder(TreeNode node) {
        List<Integer> list = new ArrayList<>();
        if (node != null) {
            list.addAll(midOrder(node.left));
            list.add(node.val);
            list.addAll(midOrder(node.right));
        }
        return list;
    }
    
    public static void main(String[] args) {
        ThreadBinaryTree threadBinaryTree = new ThreadBinaryTree();
        TreeNode treeNode = threadBinaryTree.initTree();
        List<Integer> midOrder = threadBinaryTree.midOrder(treeNode);
        System.out.println("midOrder = " + midOrder);

        threadBinaryTree.midOrderThreadedNodes(treeNode);
        System.out.println("treeNode = " + treeNode);

        List<Integer> orderThreadList = threadBinaryTree.midOrderThreadList(treeNode);
        System.out.println("orderThreadList = " + orderThreadList);
    }

    private TreeNode initTree() {
        //      1
        //   2      3
        // 4   5  6
        TreeNode node2 = new TreeNode(2, new TreeNode(4), new TreeNode(5));
        TreeNode node3 = new TreeNode(3, new TreeNode(6), null);
        return new TreeNode(1, node2, node3);
    }


    static class TreeNode {
        int val;
        // 左指針類型，0樹節點指向類型 1線索化指針,前驅節點
        int leftType;
        TreeNode left;
        // 右 指針類型，0樹節點指向類型 1線索化指針,后驅節點
        int rightType;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
}

 

　　參考：http://data.biancheng.net/view/194.html