二叉樹經常使用操做

原文：https://www.cnblogs.com/willwu/p/6007555.html

樹的介紹

1. 樹的定義

樹是一種數據結構，它是由n（n>=1）個有限節點組成一個具備層次關係的集合。

把它叫作「樹」是由於它看起來像一棵倒掛的樹，也就是說它是根朝上，而葉朝下的。它具備如下的特色：
(01) 每一個節點有零個或多個子節點；
(02) 沒有父節點的節點稱爲根節點；
(03) 每個非根節點有且只有一個父節點；
(04) 除了根節點外，每一個子節點能夠分爲多個不相交的子樹。

 

2. 樹的基本術語

若一個結點有子樹，那麼該結點稱爲子樹根的"雙親"，子樹的根是該結點的"孩子"。有相同雙親的結點互爲"兄弟"。一個結點的全部子樹上的任何結點都是該結點的後裔。從根結點到某個結點的路徑上的全部結點都是該結點的祖先。

結點的度：結點擁有的子樹的數目。
葉子：度爲零的結點。
分支結點：度不爲零的結點。
樹的度：樹中結點的最大的度。

層次：根結點的層次爲1，其他結點的層次等於該結點的雙親結點的層次加1。
樹的高度：樹中結點的最大層次。
無序樹：若是樹中結點的各子樹之間的次序是不重要的，能夠交換位置。
有序樹：若是樹中結點的各子樹之間的次序是重要的, 不能夠交換位置。
森林：0個或多個不相交的樹組成。對森林加上一個根，森林即成爲樹；刪去根，樹即成爲森林。

 

二叉樹的介紹

1. 二叉樹的定義

二叉樹是每一個節點最多有兩個子樹的樹結構。它有五種基本形態：二叉樹能夠是空集；根能夠有空的左子樹或右子樹；或者左、右子樹皆爲空。

2. 二叉樹的性質

二叉樹有如下幾個性質：TODO(上標和下標)
性質1：二叉樹第i層上的結點數目最多爲 2^{i-1} (i≥1)。
性質2：深度爲k的二叉樹至多有2^{k}-1個結點(k≥1)。
性質3：包含n個結點的二叉樹的高度至少爲log₂ (n+1)。
性質4：在任意一棵二叉樹中，若終端結點的個數爲n₀，度爲2的結點數爲n₂，則n₀=n₂+1。

 

2.1 性質1：二叉樹第i層上的結點數目最多爲 2^{i-1} (i≥1)

證實：下面用"數學概括法"進行證實。
        (01) 當i=1時，第i層的節點數目爲2^{i-1}=2^{0}=1。由於第1層上只有一個根結點，因此命題成立。
        (02) 假設當i>1，第i層的節點數目爲2^{i-1}。這個是根據(01)推斷出來的！
               下面根據這個假設，推斷出"第(i+1)層的節點數目爲2^{i}"便可。
                因爲二叉樹的每一個結點至多有兩個孩子，故"第(i+1)層上的結點數目" 最可能是 "第i層的結點數目的2倍"。即，第(i+1)層上的結點數目最大值=2×2^{i-1}=2^{i}。
                故假設成立，原命題得證！

 

2.2 性質2：深度爲k的二叉樹至多有2^{k}-1個結點(k≥1)

證實：在具備相同深度的二叉樹中，當每一層都含有最大結點數時，其樹中結點數最多。利用"性質1"可知，深度爲k的二叉樹的結點數至多爲：
           2⁰+2¹+…+2^k-1=2^k-1
           故原命題得證！

 

2.3 性質3：包含n個結點的二叉樹的高度至少爲log₂ (n+1)

證實：根據"性質2"可知，高度爲h的二叉樹最多有2^{h}–1個結點。反之，對於包含n個節點的二叉樹的高度至少爲log₂(n+1)。

 

2.4 性質4：在任意一棵二叉樹中，若終端結點的個數爲n₀，度爲2的結點數爲n₂，則n₀=n₂+1

證實：由於二叉樹中全部結點的度數均不大於2，因此結點總數(記爲n)="0度結點數(n₀)" + "1度結點數(n₁)" + "2度結點數(n₂)"。由此，獲得等式一。
         (等式一) n=n₀+n₁+n₂
　     另外一方面，0度結點沒有孩子，1度結點有一個孩子，2度結點有兩個孩子，故二叉樹中孩子結點總數是：n₁+2n₂。此外，只有根不是任何結點的孩子。故二叉樹中的結點總數又可表示爲等式二。
         (等式二) n=n₁+2n₂+1
        由(等式一)和(等式二)計算獲得：n₀=n₂+1。原命題得證！

 

3. 滿二叉樹，徹底二叉樹和二叉查找樹

3.1 滿二叉樹

定義：高度爲h，而且由2^{h} –1個結點的二叉樹，被稱爲滿二叉樹。

3.2 徹底二叉樹

定義：一棵二叉樹中，只有最下面兩層結點的度能夠小於2，而且最下一層的葉結點集中在靠左的若干位置上。這樣的二叉樹稱爲徹底二叉樹。
特色：葉子結點只能出如今最下層和次下層，且最下層的葉子結點集中在樹的左部。顯然，一棵滿二叉樹一定是一棵徹底二叉樹，而徹底二叉樹未必是滿二叉樹。

3.3 二叉查找樹

定義：二叉查找樹(Binary Search Tree)，又被稱爲二叉搜索樹。設x爲二叉查找樹中的一個結點，x節點包含關鍵字key，節點x的key值記爲key[x]。若是y是x的左子樹中的一個結點，則key[y] <= key[x]；若是y是x的右子樹的一個結點，則key[y] >= key[x]。

在二叉查找樹中：
(01) 若任意節點的左子樹不空，則左子樹上全部結點的值均小於它的根結點的值；
(02) 任意節點的右子樹不空，則右子樹上全部結點的值均大於它的根結點的值；
(03) 任意節點的左、右子樹也分別爲二叉查找樹。
(04) 沒有鍵值相等的節點（no duplicate nodes）。

java實現樹bean：

package com.sly.uploadfile.algorithm;

/**
 * Created by fmgao on 2019/7/24.
 */
public class TreeNode01<T> {
    T value;
    TreeNode01<T> leftChild;
    TreeNode01<T> rightChild;

    TreeNode01() {
    }

    TreeNode01(T value) {
        this.value = value;
    }

    /**
     * 增長左子節點
     *
     * @param value
     */
    public void addLeft(T value) {
        TreeNode01<T> leftChild = new TreeNode01<T>();
        this.leftChild = leftChild;

    }

    /**
     * 增長右子節點
     *
     * @param value
     */
    public void addRight(T value) {
        TreeNode01<T> rightChild = new TreeNode01<>();
        this.rightChild = rightChild;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof TreeNode01)) {
            return false;
        }
        return this.value.equals(((TreeNode01<?>) obj).value);
    }

    @Override
    public int hashCode() {
        return this.value.hashCode();
    }

    @Override
    public String toString() {
        return this.value == null ? "" : this.value.toString();
    }
}

 

java基本操做：

package com.sly.uploadfile.algorithm;

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

/**
 * Created by fmgao on 2019/7/24.
 */
public class TreeNodeTools {

    /**
     * 判斷樹種節點個數
     *
     * @param root
     * @param <T>
     * @return
     */
    public static <T> int getTreeNum(TreeNode01<T> root) {
        if (root == null) {
            return 0;
        }
        return getTreeNum(root.leftChild) + getTreeNum(root.rightChild) + 1;
    }

    /**
     * 判斷樹的深度
     *
     * @param root
     * @param <T>
     * @return
     */
    public static <T> int getTreeDepth(TreeNode01<T> root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = getTreeDepth(root.leftChild) + 1;
        int rightDepth = getTreeDepth(root.rightChild) + 1;
        return Math.max(leftDepth, rightDepth);
    }

    /**
     * 前序遍歷
     *
     * @param root
     * @param <T>
     */
    public static <T> void preOrderTravel(TreeNode01<T> root) {
        if (root == null) {
            return;
        }
        visitNode(root);
        preOrderTravel(root.leftChild);
        preOrderTravel(root.rightChild);

    }

    /**
     * 中序遍歷
     *
     * @param root
     * @param <T>
     */
    public static <T> void midOrderTravel(TreeNode01<T> root) {
        if (root == null) {
            return;
        }
        midOrderTravel(root.leftChild);
        visitNode(root);
        midOrderTravel(root.rightChild);

    }

    /**
     * 後續遍歷
     *
     * @param root
     * @param <T>
     */
    public static <T> void backOrderTravel(TreeNode01<T> root) {
        if (root == null) {
            return;
        }
        backOrderTravel(root.leftChild);
        backOrderTravel(root.rightChild);
        visitNode(root);

    }

    /**
     * 訪問node節點
     *
     * @param node01
     * @param <T>
     */
    public static <T> void visitNode(TreeNode01<T> node01) {
        System.out.println(node01.value + "\t");
    }

    /**
     * 分層遍歷
     *
     * @param root
     * @param <T>
     */
    public static <T> void levelTravel(TreeNode01<T> root) {
        Queue<TreeNode01<T>> q = new LinkedList<TreeNode01<T>>();
        q.offer(root);
        while (!q.isEmpty()) {
            TreeNode01<T> tmp = q.poll();
            visitNode(tmp);
            if (tmp.leftChild != null) {
                q.offer(tmp.leftChild);
            }
            if (tmp.rightChild != null) {
                q.offer(tmp.rightChild);
            }
        }

    }

    /**
     * 求第K層節點個數
     *
     * @param root
     * @param k
     * @param <T>
     * @return
     */
    public static <T> int getNumForKLevel(TreeNode01<T> root, int k) {
        if (root == null || k < 1) {
            return 0;
        }
        if (k == 1) {
            return 1;
        }
        int leftNum = getNumForKLevel(root.leftChild, k - 1);
        int rightNum = getNumForKLevel(root.rightChild, k - 1);
        return leftNum + rightNum;
    }

    /**
     * 求二叉樹種葉子節點的個數
     *
     * @param root
     * @param <T>
     * @return
     */
    public static <T> int getLeafNum(TreeNode01<T> root) {
        if (root == null) {
            return 0;
        }
        if (root.leftChild == null && root.rightChild == null) {
            return 1;
        }
        int leftNum = getLeafNum(root.leftChild);
        int rightNum = getLeafNum(root.rightChild);
        return leftNum + rightNum;
    }

    /**
     * 交換根節點的左右子樹
     *
     * @param root
     * @param <T>
     * @return
     */
    public static <T> TreeNode01<T> exchange(TreeNode01<T> root) {
        if (root == null) {
            return null;
        }
        TreeNode01<T> left = exchange(root.leftChild);
        TreeNode01<T> right = exchange(root.rightChild);
        root.leftChild = right;
        root.rightChild = left;
        return root;
    }

    /**
     * 查看node是不是root的節點
     *
     * @param root
     * @param node
     * @param <T>
     * @return
     */
    public static <T> boolean nodeIsChild(TreeNode01<T> root, TreeNode01<T> node) {
        if (root == null || node == null) {
            return false;
        }
        if (root == node) {
            return true;
        }
        boolean isFind = nodeIsChild(root.leftChild, node);
        if (!isFind) {
            isFind = nodeIsChild(root.rightChild, node);
        }
        return isFind;
    }

    /**
     * 返回lNode 和 rNode 以root爲根節點的公共父節點
     *
     * @param root
     * @param lNode
     * @param rNode
     * @param <T>
     * @return
     */
    public static <T> TreeNode01<T> findAllFatherNode(TreeNode01<T> root, TreeNode01<T> lNode, TreeNode01<T> rNode) {
        if (lNode == root || rNode == root) {
            return root;
        }
        if (root == null || lNode == null || rNode == null) {
            return null;
        }
        // 若是lNode是左子樹的節點
        if (nodeIsChild(root.leftChild, lNode)) {
            if (nodeIsChild(root.rightChild, rNode)) {
                return root;
            } else {
                return findAllFatherNode(root.leftChild, lNode, rNode);
            }
        } else {
            if (nodeIsChild(root.leftChild, rNode)) {
                return root;
            } else {
                return findAllFatherNode(root.rightChild, lNode, rNode);
            }
        }
    }

    /**
     * 根據前序和中序構建二叉樹
     *
     * @param pre
     * @param mid
     * @param <T>
     * @return
     */
    public static <T> TreeNode01<T> getTreeFromPreAndMid(List<T> pre, List<T> mid) {
        if (pre == null || mid == null || pre.size() == 0 || mid.size() == 0) {
            return null;
        }
        if (pre.size() == 1) {
            return new TreeNode01<T>(pre.get(0));
        }
        TreeNode01<T> root = new TreeNode01<T>(pre.get(0));
        // 找出根節點在中序中的位置
        int index = 0;
        while (!mid.get(index++).equals(pre.get(0))) {

        }

        // 構建左子樹的前序
        List<T> preLeft = new ArrayList<T>(index);

        // 中子樹的前序
        List<T> midLeft = new ArrayList<T>(index);
        for (int i = 1; i < index; i++) {
            preLeft.add(pre.get(i));
        }
        for (int i = 0; i < index - 1; i++) {
            midLeft.add(mid.get(i));
        }
        // 重建左子樹
        root.leftChild = getTreeFromPreAndMid(preLeft, midLeft);
        // 右子樹的前序
        List<T> preRight = new ArrayList<T>(pre.size() - index - 1);
        // 右子樹的中序
        List<T> midRight = new ArrayList<T>(pre.size() - index - 1);
        for (int i = 0; i <= pre.size() - index - 1; i++) {
            preRight.add(pre.get(index + i));
        }

        for (int i = 0; i <= pre.size() - index - 1; i++) {
            midRight.add(mid.get(index + i));
        }
        // 重建→子樹
        root.rightChild = getTreeFromPreAndMid(preRight, midRight);
        return root;

    }

    public static <T> boolean equals(TreeNode01<T> node1, TreeNode01<T> node2) {
        if (node1 == null && node2 == null) {
            return true;
        } else if (node1 == null || node2 == null) {
            return false;
        }
        boolean isEqual = node1.value.equals(node2.value);
        boolean isLeftEqual = equals(node1.leftChild, node2.leftChild);
        boolean isRightEqual = equals(node1.rightChild, node2.rightChild);
        return isEqual && isLeftEqual && isRightEqual;

    }

}