[演算法系列]遞回應用——二叉樹（2）：一種帶資訊遞迴返回的求解方式

本文是遞迴系列文的第七篇，和上篇文章類似，介紹BinaryTree的解題思路。這裡介紹一種和“遍歷”行為類似的，自下而上遞迴返回資訊的解題思路。其規則的寫法、並不複雜的思路，可解決大多bintree中與子樹有關的問題（但願吧哈哈哈）

0.引子：求二叉樹節點中的最大值和最小值

此題當然可以通過遍歷整棵二叉樹，將遍歷途中遇到的最大值和最小值進行儲存。遍歷完成後maxVal和minVla即為所求：

class MaxAndMinInBinTree{
    int maxVal = Integer.MIN_VALUE;
    int minVal = Integer.MAX_VALUE;
    public  int[] getMinMaxInBT(TreeNode node){
        process(node);
        return new int[]{maxVal, minVal};
    }
    public void process(TreeNode node){
        if(node == null) return;

        maxVal = Math.max(node.val , maxVal);
        minVal = Math.min(node.val, minVal);
        process(node.left);
        process(node.right);
    }
}

那麼這道題目除了用 二叉樹的 ”遍歷“ 思路，還可以怎麼想呢？

回憶我們求二叉樹的高度時用到的思路：

1. 當前子樹的高度 =max（ 左子樹的高度 ，右子樹高度）+ 1
2. 在遞迴中逐漸返回到頭結點：樹的高度 = max（根的子樹高度，根的右子樹高度） +1

這其實就是一種和遍歷思路稍顯區別的，俺將其命名為帶資訊返回的求解思路。那麼如果將其運用到求整棵樹的最大最小值時，就可以自然而然地有如下想法：

1. 當前子樹的最大值 = max(左子樹最大值，右子樹最大值，當前節點的值)
2. 當前子樹的最小值 = min(左子樹最小值，右子樹最小值，當前節點的值)
3. 在遞迴中逐漸向上返回到根節點。

該思路其一般可寫成如下框架：

public ReturnData process(TreeNode node){
    if(node == null){
        //處理節點為空的情況，也是”遞“到達的最深處，”歸“上去的起點
    }
    ReturnData leftDate = process(node.left);
    ReturnData rightData = process(node.right);
    
    return new ReturnData(
    	//根據當前節點考慮可能性，構造當前要向上返回的資訊集
    )
}

下面來解釋一波上述的虛擬碼：

1. ReturnData是自定義的一個類，裡面包含的是遞迴過程中每次需要返回的所有資訊

2. 看整個process函式框架，看過我前面詳解遞迴的小夥伴應該比較清楚：node == null 實際上就是邊界條件，是遞迴的出口，在此處我們需要拿捏最小問題的處理方式。

   緊接著，是兩個遞迴呼叫process的過程，用leftData和rightData去接收左子樹和右子樹的結果。這一點前面也提到過：該模式下process函式會一口氣走到最左下的為null的節點，然後再返回到右下，從葉節點開始，逐漸往上地返回。

   在返回過程中，構建了一個新的ReturnData例項物件。這也就把所需要返回的資訊向上地”歸“到了根節點。

3. 在新構建返回資訊的例項物件中，就是我們根據可能性進行構造的過程。

好了，現在看看用這個方法時怎樣操作的：

class MaxAndMinInBinTree2{
    /* 這個題的返回資訊就是所要求的最大值，最小值 */
    public static class ReturnData{
        public int maxVal;
        public int minVal;
        public ReturnData(int maxVal , int minVal){
            this.maxVal = maxVal;
            this.minVal = minVal;
        }
    }

    public void getMinMax(TreeNode node){
        ReturnData data = process(node);
        System.out.println(data.maxVal + "  " + data.minVal);
    }
    private ReturnData process(TreeNode head){
        /* 遞迴邊界條件，構造最初的返回資訊 */                                                                                            */
        if(head == null){
            return  new ReturnData(Integer.MIN_VALUE, Integer.MAX_VALUE);
        }

        ReturnData leftData = process(head.left);
        ReturnData rightData = process(head.right);
        /* 逐漸向上遞迴的資訊，由每一層的各種可能性決定：
        	比如：當前子樹的最大值 = max(左子樹最大值，右子樹最大值，當前節點的值) */
        return new ReturnData(
                Math.max(Math.max(leftData.maxVal ,rightData.maxVal),head.val),
                Math.min(Math.min(leftData.minVal , rightData.minVal),head.val)
        );
    }
}

1.判斷一個二叉樹是否平衡

在引子中，我們分別用”遍歷“和"遞迴資訊返回"兩種思路求得了一顆二叉樹中最大最小值，可以體會一下這兩種思路的區別和聯絡。

看上去第二種方法要比第一種更繁瑣，其實不然。因為，求二叉樹中最大值這種問題，天然就屬於是遍歷可解的問題，當然遍歷就好啦。

但是，”遍歷“固然好，有些問題並不適合用遍歷的方式做，比如一些直接或間接與子樹有關的問題，比如就求一棵樹中滿足xxx條件的最大子樹，或者像這個” 判斷一個二叉樹是否平衡“。下面來體會一下。

（1）設計ReturnData。

判斷是否平衡，需要一個isBalance的boolean變數來判斷。另外，判斷是否平衡實際上是根據左右子樹的高度差來決定的，因此還需要一個int h來儲存當前節點高度。在遞迴過程中傳遞這兩個值

（2）思考遞迴邊界條件。

依舊是head為null的情況，此時返回的資訊為isBalance=true，h=0，

（3）考慮每一次遞迴返回資訊中的個屬性賦值的可能性。

當前樹為平衡樹的條件為：左子樹為平衡的 && 右子樹為平衡的 && 左右子樹高度差<=1

因此，若左子樹不平衡，直接返回不平衡。右子樹不平衡，直接返回不平衡。高度差 > 1直接返回不平衡。

三者都通過了，就可在返回的資訊中把isBalance置為true，同時求其高度了。

class CheckBlance{
    public static class ReturnData{
        public boolean isBalance;
        public int h;

        public  ReturnData(boolean isB, int h){
            this.isBalance = isB;
            this.h = h;
        }
    }

    public  ReturnData process(TreeNode head){
        if(head == null){
            return new ReturnData(true ,0);
        }

        ReturnData leftReturnData = process(head.left);
        /*當左子樹不平衡時，當前樹定不平衡，可以不用再考慮右樹了。
            這裡isB為false，直接返回到根處都不為平衡，
            因此h實際上沒啥用
         */
        if(!leftReturnData.isBalance)
            return new ReturnData(false, 0);

        ReturnData rightRetunrData =process(head.left);
        //當左子樹不平衡時，當前樹定不平衡，可以不用再考慮當前節點了
        if(!rightRetunrData.isBalance)
            return new ReturnData(false,0);

        //判斷平衡調節並返回
        if(Math.abs(leftReturnData.h - rightRetunrData.h) > 1 )
            return new ReturnData(false,0);

        //能到這個位置，說明一定是平衡的，此時h才有他的用武之地
        return new ReturnData(true , Math.max(leftReturnData.h , rightRetunrData.h) + 1);
    }
}

2.求二叉樹中最大的二叉搜尋子樹

通過上面的兩道可以看出這種方法還是挺可以的叭~

給一顆二叉樹，返回該二叉樹中最大的二叉搜尋子樹，比如下圖中的最大二叉搜尋子樹為紅圈中部分。

（1）設計ReturnData。

ReturnData需要四個資訊：

1. 當前節點的最大子BST的size： size。

   這個不用解釋了吧，最後要求的就是這個

2. 當前節點的最大子BST的頭結點：head。

   考慮一下，若左子樹的head是當前的左子樹，右子樹的head就是當前節點右子樹，是不是可能這三個連成一塊變成一個更大的BST呢？

3. 當前節點的最小值和最大值

   光是滿足2是不夠的，還得需要左子樹的最大值小於當前節點值，右子樹的最小值大於當前節點值才行。

（2）思考遞迴邊界條件。

當節點為null時。size為0，maxHead為null，最大值儲存系統最小值，最小值儲存系統最大值

（3）考慮每一次遞迴返回資訊中的個屬性賦值的可能性。

1. size：有三種可能：

   左子樹的子BST的size最大時，size = leftData.size

   右子樹的子BST的size最大時，size = rightData.size

   左子樹、右子樹、當前節點連成一個BST時，size為 leftData.size + 1+ rightData.size

2. head：同樣是三可能：

   head = leftData.head

   head = rightData.head

   head = 當前節點

3. min 和 max，

   考察左子樹的min、max，右子樹min、max和當前節點值即可

下面為程式碼

class FindSubBST{
    public static class ReturnData{
        public int size;
        public TreeNode head;
        public int min;
        public int max;

        public ReturnData(int size,TreeNode head,int min ,int max){
            this.size = size;
            this.head = head;
            this.min = min;
            this.max = max;
        }
    }
	public Node getMaxSizeSubBST(TreeNode head){
    	return process(head).head;   
    }    
    
    public ReturnData process(TreeNode head){
        if(head == null){
            return  new ReturnData(0,null,Integer.MAX_VALUE,Integer.MIN_VALUE);
        }

        TreeNode left = head.left;
        TreeNode right = head.right;
        ReturnData leftData = process(left);
        ReturnData rightData = process(right);

        /*  左孩子就是左BST的頭 右孩子也是右子BST的頭
                   且
                   左孩子的最大值小於當前節點值
                   右孩子的最小值小於當前節點值
            此時將三個部分合並，即為所求
         */
        int includeItSelf = 0;
        if(leftData.head == left && rightData.head == right
            && leftData.max < head.val && rightData.min > head.val)
            includeItSelf = leftData.size + 1 + rightData.size;

        /*
           maxSize的三種可能性：
            左子樹，右子樹，才求的三合一
         */
        int p1 = leftData.size;
        int p2 = rightData.size;
        int maxSize = Math.max(Math.max(p1,p2),includeItSelf);

        /*
            maxHead的三種可能性:
             maxSize為左子樹時： maxHead為左子樹頭
             maxSize為右子樹時： maxHead為右子樹頭
              maxSize為includeItSelf時 ： 說明已經三者合1，maxHead為當前節點
         */
        TreeNode maxHead = p1 > p2 ? leftData.head : rightData.head;
        if(maxSize == includeItSelf)
            maxHead = head;

        /* 所有資訊的所有可能性討論完畢，構建一個新物件返回 */
        return new ReturnData(maxSize, maxHead ,
                Math.min(Math.min(leftData.min, rightData.min),head.val),
                Math.min(Math.max(leftData.max, rightData.max),head.val)
            );
    }
}

小結

其實之前在做此類題時，採用遞迴方法會在遞迴中幹許多事情，或者還會設定全域性變數、中間值啥的。而該方法比較清晰地將每次遞迴需要做什麼事情，傳遞什麼資訊打包。在每次呼叫時可以只用關注傳遞資訊中的每個值得所有可能性。

另外，進一步理解遞迴設計、應用或者對遞迴過程有所疑惑的小夥伴可瀏覽之前的文章：

1. [演算法系列] 搞懂遞迴, 看這篇就夠了 !! 遞迴設計思路 + 經典例題層層遞進
2. [演算法系列] 遞回應用: 快速排序+歸併排序演算法及其核心思想與擴充 … 附贈 堆排序演算法
3. [演算法系列] 深入遞迴本質+經典例題解析——如何逐步生成, 以此類推,步步為營
4. [演算法系列]搞懂DFS(1)——經典例題(數獨遊戲, 部分和, 水窪數目)圖文詳解
5. [演算法系列]搞懂DFS(2)——模式套路+經典例題詳解（n皇后問題，素數環問題）
6. [演算法系列]遞回應用——二叉樹（1）：二叉樹遍歷詳解解+LeetCode經典題目+模板總結

待續。。。