二叉樹就是這麼簡單

前言

只有光頭才能變強。

文本已收錄至個人GitHub倉庫，歡迎Star： https://github.com/ZhongFuCheng3y/3y

1、二叉樹就是這麼簡單

本文撇開一些很是苦澀、難以理解的概念來說講二叉樹，僅入門觀看(或複習)....

首先，咱們來說講什麼是樹：

• 樹是一種非線性的數據結構，相對於線性的數據結構(鏈表、數組)而言，樹的平均運行時間更短(每每與樹相關的排序時間複雜度都不會高)

在現實生活中，咱們通常的樹長這個樣子的：

可是在編程的世界中，咱們通常把樹「倒」過來看，這樣容易咱們分析：

通常的樹是有不少不少個分支的，分支下又有不少不少個分支，若是在程序中研究這個會很是麻煩。由於原本樹就是非線性的，而咱們計算機的內存是線性存儲的，太過複雜的話咱們沒法設計出來的。

所以，咱們先來研究簡單又常常用的---> 二叉樹

1.1樹的一些概念

我就拿上面的圖來進行畫來說解了：

二叉樹的意思就是說：每一個節點不能多於有兩個兒子，上面的圖就是一顆二叉樹。

• 一棵樹至少會有一個節點(根節點)
• 樹由節點組成，每一個節點的數據結構是這樣的：
• 所以，咱們定義樹的時候每每是->定義節點->節點鏈接起來就成了樹，而節點的定義就是：一個數據、兩個指針(若是有節點就指向節點、沒有節點就指向null)

1.2靜態建立二叉樹

上面說了，樹是由若干個節點組成，節點鏈接起來就成了樹，而節點由一個數據、兩個指針組成

• 所以，建立樹實際上就是建立節點，而後鏈接節點

首先，使用Java類定義節點：

public class TreeNode {

    // 左節點(兒子)
    private TreeNode lefTreeNode;
    
    // 右節點(兒子)
    private TreeNode rightNode;
    
    // 數據
    private int value;
    

}

下面咱們就拿這個二叉樹爲例來構建吧：

爲了方便構建，我就給了它一個帶參數的構造方法和set、get方法了：

public TreeNode(int value) {

        this.value = value;
    }

那麼咱們如今就建立了5個節點：

public static void main(String[] args) {

        //根節點-->10
        TreeNode treeNode1 = new TreeNode(10);

        //左孩子-->9
        TreeNode treeNode2 = new TreeNode(9);

        //右孩子-->20
        TreeNode treeNode3 = new TreeNode(20);
        
        //20的左孩子-->15
        TreeNode treeNode4 = new TreeNode(15);
        
        //20的右孩子-->35
        TreeNode treeNode5 = new TreeNode(35)        
      
    }

它們目前的狀態是這樣子的：

因而下面咱們去把它連起來：

//根節點的左右孩子
    treeNode1.setLefTreeNode(treeNode2);
    treeNode1.setRightNode(treeNode3);

    //20節點的左右孩子
    treeNode3.setLefTreeNode(treeNode4);
    treeNode3.setRightNode(treeNode5);

鏈接完以後，那麼咱們的樹就建立完成了。

1.3遍歷二叉樹

上面說咱們的樹建立完成了，那怎麼證實呢？？咱們若是能夠像數組同樣遍歷它(看它的數據)，那就說明它建立完成了～

值得說明的是：二叉樹遍歷有三種方式

• 先序遍歷

  • 先訪問根節點，而後訪問左節點，最後訪問右節點(根->左->右)

• 中序遍歷

  • 先訪問左節點，而後訪問根節點，最後訪問右節點(左->根->右)

• 後序遍歷

  • 先訪問左節點，而後訪問右節點，最後訪問根節點(左->右->根)

以上面的二叉樹爲例：

• 若是是先序遍歷：10->9->20->15->35

• 若是是中序遍歷：9->10->15->20->35

  • 可能須要解釋地方：訪問完10節點事後，去找的是20節點，但20下還有子節點，所以先訪問的是20的左兒子15節點。因爲15節點沒有兒子了。因此就返回20節點，訪問20節點。最後訪問35節點

• 若是是後序遍歷：9->15->35->20->10

  • 可能須要解釋地方：先訪問9節點，隨後應該訪問的是20節點，但20下還有子節點，所以先訪問的是20的左兒子15節點。因爲15節點沒有兒子了。因此就去訪問35節點，因爲35節點也沒有兒子了，因此返回20節點，最終返回10節點

一句話總結：先序(根->左->右)，中序(左->根->右)，後序(左->右->根)。若是訪問有孩子的節點，先處理孩子的，隨後返回

不管先中後遍歷，每一個節點的遍歷若是訪問有孩子的節點，先處理孩子的(邏輯是同樣的)

• 所以咱們很容易想到遞歸
• 遞歸的出口就是：當沒有子節點了，就返回

所以，咱們能夠寫出這樣的先序遍歷代碼：

/**
     * 先序遍歷
     * @param rootTreeNode  根節點
     */
    public static void preTraverseBTree(TreeNode rootTreeNode) {

        if (rootTreeNode != null) {

            //訪問根節點
            System.out.println(rootTreeNode.getValue());

            //訪問左節點
            preTraverseBTree(rootTreeNode.getLefTreeNode());

            //訪問右節點
            preTraverseBTree(rootTreeNode.getRightNode());
        }
    }

結果跟咱們剛纔說的是同樣的：

咱們再用中序遍歷調用一遍吧：

/**
     * 中序遍歷
     * @param rootTreeNode  根節點
     */
    public static void inTraverseBTree(TreeNode rootTreeNode) {

        if (rootTreeNode != null) {

            //訪問左節點
            inTraverseBTree(rootTreeNode.getLefTreeNode());

            //訪問根節點
            System.out.println(rootTreeNode.getValue());

            //訪問右節點
            inTraverseBTree(rootTreeNode.getRightNode());
        }
    }

結果跟咱們剛纔說的是同樣的：

有意思的是：經過先序和中序或者中序和後序咱們能夠還原出原始的二叉樹，可是經過先序和後序是沒法還原出原始的二叉樹的

• 也就是說：經過中序和先序或者中序和後序咱們就能夠肯定一顆二叉樹了！

2、動態建立二叉樹

上面咱們是手動建立二叉樹的，通常地：都是給出一個數組給你，讓你將數組變成一個二叉樹，此時就須要咱們動態建立二叉樹了。

二叉樹中還有一種特殊的二叉樹：二叉查找樹(binary search tree)

• 定義：當前根節點的左邊所有比根節點小，當前根節點的右邊所有比根節點大。

  • 明眼人能夠看出，這對咱們來找一個數是很是方便快捷的

每每咱們動態建立二叉樹都是建立二叉查找樹

2.1動態建立二叉樹體驗

假設咱們有一個數組：int[] arrays = {3, 2, 1, 4, 5};

那麼建立二叉樹的步驟是這樣的：

• 首先將3做爲根節點

• 隨後2進來了，咱們跟3作比較，比3小，那麼放在3的左邊

• 隨後1進來了，咱們跟3作比較，比3小，那麼放在3的左邊，此時3的左邊有2了，所以跟2比，比2小，放在2的左邊

• 隨後4進來了，咱們跟3作比較，比3大，那麼放在3的右邊

• 隨後5進來了，咱們跟3作比較，比3大，那麼放在3的右邊，此時3的右邊有4了，所以跟4比，比4大，放在4的右邊

那麼咱們的二叉查找樹就創建成功了，不管任何一顆子樹，左邊都比根要小，右邊比根要大

2.2代碼實現

咱們的代碼實現也很簡單，若是比當前根節點要小，那麼放到當前根節點左邊，若是比當前根節點要大，那麼放到當前根節點右邊。

由於是動態建立的，所以咱們得用一個類來表示根節點

public class TreeRoot {

    private TreeNode treeRoot;

    public TreeNode getTreeRoot() {
        return treeRoot;
    }

    public void setTreeRoot(TreeNode treeRoot) {
        this.treeRoot = treeRoot;
    }
}

比較與根誰大，大的往右邊，小的往左邊：

/**
     * 動態建立二叉查找樹
     *
     * @param treeRoot 根節點
     * @param value    節點的值
     */
    public static void createTree(TreeRoot treeRoot, int value) {


        //若是樹根爲空(第一次訪問)，將第一個值做爲根節點
        if (treeRoot.getTreeRoot() == null) {
            TreeNode treeNode = new TreeNode(value);
            treeRoot.setTreeRoot(treeNode);

        } else  {

            //當前樹根
            TreeNode tempRoot = treeRoot.getTreeRoot();

            while (tempRoot != null) {
                //當前值大於根值，往右邊走
                if (value > tempRoot.getValue()) {

                    //右邊沒有樹根，那就直接插入
                    if (tempRoot.getRightNode() == null) {
                        tempRoot.setRightNode(new TreeNode(value));
                        return ;
                    } else {
                        //若是右邊有樹根，到右邊的樹根去
                        tempRoot = tempRoot.getRightNode();
                    }
                } else {
                    //左沒有樹根，那就直接插入
                    if (tempRoot.getLefTreeNode() == null) {
                        tempRoot.setLefTreeNode(new TreeNode(value));

                        return;
                    } else {
                        //若是左有樹根，到左邊的樹根去
                        tempRoot = tempRoot.getLefTreeNode();
                    }
                }
            }
        }
    }

測試代碼：

int[] arrays = {2, 3, 1, 4, 5};

    //動態建立樹

    TreeRoot root = new TreeRoot();
    for (int value : arrays) {
        createTree(root, value);
    }


    //中序遍歷樹
    inTraverseBTree(root.getTreeRoot());
    System.out.println("---------------公衆號：Java3y");
    
    //先序遍歷樹
    preTraverseBTree(root.getTreeRoot());
    System.out.println("---------------公衆號：Java3y");

3、查詢二叉查找樹相關

3.1查詢樹的深度

查詢樹的深度咱們能夠這樣想：左邊的子樹和右邊的字數比，誰大就返回誰，那麼再接上根節點+1就能夠了

public static int getHeight(TreeNode treeNode) {

        if (treeNode == null) {
            return 0;
        } else {

            //左邊的子樹深度
            int left = getHeight(treeNode.getLefTreeNode());

            //右邊的子樹深度
            int right = getHeight(treeNode.getRightNode());


            int max = left;

            if (right > max) {
                max = right;
            }
            return max + 1;
        }
    }

3.1查詢樹的最大值

從上面先序遍歷二叉查找樹的時候，細心的同窗可能會發現：中序遍歷二叉查找樹獲得的結果是排好順序的～

那麼，若是咱們的二叉樹不是二叉查找樹，咱們要怎麼查詢他的最大值呢？

能夠這樣：

• 左邊找最大值->遞歸
• 右邊找最大值->遞歸

/**
     * 找出樹的最大值
     *
     * @param rootTreeNode
     */
    public static int  getMax(TreeNode rootTreeNode) {

        if (rootTreeNode == null) {
            return -1;
        } else {
            //找出左邊的最大值
            int left = getMax(rootTreeNode.getLefTreeNode());

            //找出右邊的最大值
            int right = getMax(rootTreeNode.getRightNode());

            //與當前根節點比較
            int currentRootValue = rootTreeNode.getValue();

            //假設左邊的最大
            int max = left;


            if (right > max) {
                max = right;
            }
            if (currentRootValue > max) {
                max = currentRootValue;
            }

            return max ;


        }
    }

4、最後

不管是在遍歷樹、查找深度、查找最大值都用到了遞歸，遞歸在非線性的數據結構中是用得很是多的...

樹的應用也很是普遍，此篇簡單地說明了樹的數據結構，高級的東西我也沒弄懂，可能之後用到的時候會繼續深刻...

樂於輸出 乾貨的Java技術公衆號：Java3y。公衆號內有200多篇 原創技術文章、海量視頻資源、精美腦圖，不妨來 關注一下！