第六章 二叉樹part08

第六章 二叉樹part08

669. 修剪二叉搜尋樹 108.將有序陣列轉換為二叉搜尋樹

538.把二叉搜尋樹轉換為累加樹

669. 修剪二叉搜尋樹

題目 連結 :

669. 修剪二叉搜尋樹 - 力扣（LeetCode）

Code ( 非遞迴 分支 處理 + 狀態碼 的 使用 ( 處理 過程 狀態碼 + “ Result 情況 狀態碼 ” + 後端 處理 狀態碼 ) ) :

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
​
        // Think  
​
        // Need Think  
​
        if(root == nullptr )
        {
​
            return root ;
​
​
        }
​
​
        // 對 左  邊界  的  處理  /  相關 處理  
​
        int val_root = root->val ;
​
        TreeNode * node_Work_For_LeftSide = root ;
​
        TreeNode * node_Pre_From_Work_For_LeftSide = nullptr ;
​
        TreeNode * root_New_For_Return = root ;
​
        // 歷史 指標  可以   選擇 性  的  使用    
​
        // xx 結點 內  的 資訊 也要  Authentication  
​
        // 這裡 是 xx 結點  /  Target 結點 右 子 結點 的 情況  
​
        int state_code_Front_For_LeftSide = 0 ;
​
        // 1 左 搜  
        // 2 右 搜  
​
        int state_code_Backward_For_LeftSide = 0 ;
​
        //cout<<111111111<<endl;
        
​
        if(low < val_root )
        {
            state_code_Front_For_LeftSide = 1 ;
​
            while(1)
            {
                //cout<< " node_Work_For_LeftSide->val :  " << node_Work_For_LeftSide->val<<endl;
​
                //cout<<1111<<endl;
​
                //cout<<111111111<<endl;
​
                if( state_code_Front_For_LeftSide == 1 )
                {
                    // Think
​
                    // Debug 
​
                    // Think  
​
​
                    //cout<<2222<<endl;
                    if( low < node_Work_For_LeftSide -> val )
                    {
                        node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                        if(node_Work_For_LeftSide -> left != nullptr && node_Work_For_LeftSide->val >= low  )
                        {
                            node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
                        }
                        else
                        {
                            if(node_Work_For_LeftSide -> left == nullptr)
                            {
                                state_code_Backward_For_LeftSide = 3 ; // 二叉搜尋樹 內 的 結點 值  均在  左邊界  範圍  內    
                            
                                // 動態 處理 資料結構  
​
                                //cout<<111111111<<endl;
​
                                break ;
                            }
                            else if(node_Work_For_LeftSide->val < low)
                            {
                                node_Pre_From_Work_For_LeftSide -> left = nullptr ;
​
                                break ;
​
​
                            }
                            
​
                        }
​
​
​
                    }
                    else if( low == node_Work_For_LeftSide -> val )
                    {
                        //cout<< " node_Work_For_LeftSide->val :  " << node_Work_For_LeftSide->val<<endl;
                        //cout<<2222<<endl;
                        // 結點 值  唯一 時 的 處理 
​
                        // 結點 值  不 唯一 時 的 處理  
                        // if 對 此 題 
​
                        while( node_Work_For_LeftSide->left != nullptr && node_Work_For_LeftSide->left->val == node_Work_For_LeftSide->val )
                        {
                            node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                            node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
                        }
​
                        //cout<< " node_Work_For_LeftSide->val :  " << node_Work_For_LeftSide->val<<endl;
                    
                        state_code_Backward_For_LeftSide = 4 ; // 找到 了 “ ( 未來 的  ) 左 邊界點 ” 
                        
                        node_Work_For_LeftSide -> left = nullptr ;
                        
                        break ;
​
                    }
                    else if( low > node_Work_For_LeftSide -> val )
                    {
​
                        
​
                        if(node_Work_For_LeftSide -> right != nullptr )
                        {
                            state_code_Front_For_LeftSide = 2 ;
​
                            continue ;
​
                        }
                        else
                        {
                            //右側 無 “ 夾層 子節點 ”
                            state_code_Backward_For_LeftSide = 5 ;
​
                            node_Pre_From_Work_For_LeftSide -> left = nullptr ;
​
                            break ;
​
​
                        }
​
​
​
                    }
​
​
                }
                else if(state_code_Front_For_LeftSide == 2 )
                {
                    if(node_Work_For_LeftSide -> right != nullptr && node_Work_For_LeftSide->val < low  )
                    {
                        // 之前 的 Pre 結點 已經 找到 了 所 需 位置 , 故 開始 保留 其 所在 位置 的 地址 / or 交 由  其它 指標 儲存 , 並 繼續 前進 ( 這裡 是 跟進  )  /  處理 + 跟進    
                        //node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide 
​
                        node_Work_For_LeftSide = node_Work_For_LeftSide -> right ;
​
                    }
                    else
                    {
                        //右側 有 “ 夾層 子節點 ”
                        if(node_Work_For_LeftSide->val >= low )
                        {
                            node_Pre_From_Work_For_LeftSide -> left = node_Work_For_LeftSide ;
                            node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
                        }
                        else if(node_Work_For_LeftSide->right == nullptr )
                        {
                            //右側 無 “ “ 所需 ” 夾層 子節點 ”
​
                            break ;
​
​
                        }
                        
​
                        if(node_Work_For_LeftSide -> left != nullptr )
                        {
                            state_code_Front_For_LeftSide = 3 ;
​
                            continue ;  
​
​
​
​
                        }
                        else
                        {
​
                            
                            state_code_Backward_For_LeftSide = 6 ;
​
                            break ;
​
​
​
                        }
​
​
                        
​
​
                    }
​
                    // 易於 實現 的 方法  
​
                    // 維護 資料結構 執行 效率 的 方法 
​
                    // 計算機 處理 效率 / 效率 化 的 方法  
​
​
                }
                else if(state_code_Front_For_LeftSide == 3 )
                {
                    // 輕量化 設計  
                    // Simple 化 設計 
                    // 要 達到 標準 
                    // 模組化 設計  支援    
​
                    if( node_Work_For_LeftSide->left != nullptr && low < node_Work_For_LeftSide -> val )
                    {
                        node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                        node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
​
​
​
                    }
                    else if( low == node_Work_For_LeftSide -> val )
                    {
​
                        // 結點 值  唯一 時 的 處理 
​
                        // 結點 值  不 唯一 時 的 處理  
                        // if 對 此 題 
​
                        while( node_Work_For_LeftSide->left != nullptr && node_Work_For_LeftSide->left->val == node_Work_For_LeftSide->val )
                        {
                            node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                            node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
                        }
​
​
                        state_code_Backward_For_LeftSide = 7 ; // 找到 了 “ ( 未來 的  ) 左 邊界點 ” 
​
                        node_Work_For_LeftSide -> left = nullptr ;
​
                        break ;
​
                    }
                    else if( low > node_Work_For_LeftSide -> val )
                    {
​
                        if(node_Work_For_LeftSide -> right != nullptr )
                        {
​
                            state_code_Front_For_LeftSide = 2 ;
​
                            continue ;
​
                        }
                        else
                        {
                            //右側 無  “ “ 下 一 ” 夾層 子節點 ”
                            state_code_Backward_For_LeftSide = 9 ;
​
                            node_Pre_From_Work_For_LeftSide -> left ;
​
                            break ;
​
​
                        }
​
​
​
                    }
                    else if( node_Work_For_LeftSide -> left == nullptr )
                    {
                        state_code_Backward_For_LeftSide = 8 ; // 此 下降 階段  的 結點 值  均在  左邊界  範圍  內    
                        
                        break ;
​
​
                    }
​
​
​
​
                }
                
​
​
​
            }
​
        }
        else if( low == val_root )
        {
            node_Work_For_LeftSide = root ;
            while(node_Work_For_LeftSide->left != nullptr && node_Work_For_LeftSide->left->val == node_Work_For_LeftSide->val )
            {
                node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
            }
​
            node_Work_For_LeftSide -> left = nullptr ;
​
​
        }
        else if( low > val_root )
        {
            state_code_Front_For_LeftSide = 4 ;
​
            while(1)
            {
                //cout<< "node_Work_For_LeftSide->val : " << node_Work_For_LeftSide->val << endl ;
                if( state_code_Front_For_LeftSide == 4 )
                {
                    if(node_Work_For_LeftSide -> right != nullptr && node_Work_For_LeftSide->val < low  )
                    {
                        // 之前 的 Pre 結點 已經 找到 了 所 需 位置 , 故 開始 保留 其 所在 位置 的 地址 / or 交 由  其它 指標 儲存 , 並 繼續 前進 ( 這裡 是 跟進  )  /  處理 + 跟進    
                        //node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide 
​
                        node_Work_For_LeftSide = node_Work_For_LeftSide -> right ;
​
                    }
                    else
                    {
                        // 更新 根 結點  
                        if(node_Work_For_LeftSide->val >= low )
                        {
                            root_New_For_Return = node_Work_For_LeftSide ;
​
                            node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                        }
                        else if(node_Work_For_LeftSide->right == nullptr )
                        {
                            // 無 符合 要求 的 子節點  
​
                            root_New_For_Return = nullptr ;
​
                            break ;
​
​
                        }
                        
​
                        if(node_Work_For_LeftSide -> left != nullptr )
                        {
                            state_code_Front_For_LeftSide = 3 ;
​
                            continue ;  
​
​
​
​
                        }
                        else
                        {
​
                            
                            state_code_Backward_For_LeftSide = 6 ;
​
                            break ;
​
​
​
                        }
​
​
                        
​
​
                    }
                    
​
​
                }
                else if(state_code_Front_For_LeftSide == 2 )
                {
                    if(node_Work_For_LeftSide -> right != nullptr && node_Work_For_LeftSide->val < low  )
                    {
                        // 之前 的 Pre 結點 已經 找到 了 所 需 位置 , 故 開始 保留 其 所在 位置 的 地址 / or 交 由  其它 指標 儲存 , 並 繼續 前進 ( 這裡 是 跟進  )  /  處理 + 跟進    
                        //node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide 
​
                        node_Work_For_LeftSide = node_Work_For_LeftSide -> right ;
​
                    }
                    else
                    {
                        //右側 有 “ 夾層 子節點 ”
                        if(node_Work_For_LeftSide->val >= low )
                        {
                            node_Pre_From_Work_For_LeftSide -> left = node_Work_For_LeftSide ;
                            node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
                        }
                        else if(node_Work_For_LeftSide->right == nullptr )
                        {
                            //右側 無 “ “ 所需 ” 夾層 子節點 ”
​
                            break ;
​
​
                        }
                        
​
                        if(node_Work_For_LeftSide -> left != nullptr )
                        {
                            state_code_Front_For_LeftSide = 3 ;
​
                            continue ;  
​
​
​
​
                        }
                        else
                        {
​
                            
                            state_code_Backward_For_LeftSide = 9 ;
​
                            break ;
​
​
​
                        }
​
​
                        
​
​
                    }
​
                    // 易於 實現 的 方法  
​
                    // 維護 資料結構 執行 效率 的 方法 
​
                    // 計算機 處理 效率 / 效率 化 的 方法  
​
​
                }
                else if(state_code_Front_For_LeftSide == 3 )
                {
                    // 輕量化 設計  
                    // Simple 化 設計 
                    // 要 達到 標準 
                    // 模組化 設計  支援    
​
                    if( node_Work_For_LeftSide->left != nullptr && low < node_Work_For_LeftSide -> val )
                    {
                        node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                        node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
​
​
​
                    } // 注意 分支 處理 優先順序 / 順序
                    else if( low == node_Work_For_LeftSide -> val )
                    {
​
                        // 結點 值  唯一 時 的 處理 
​
                        // 結點 值  不 唯一 時 的 處理  
                        // if 對 此 題 
​
                        while( node_Work_For_LeftSide->left != nullptr && node_Work_For_LeftSide->left->val == node_Work_For_LeftSide->val )
                        {
                            node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide ;
​
                            node_Work_For_LeftSide = node_Work_For_LeftSide -> left ;
​
                        }
​
​
                        state_code_Backward_For_LeftSide = 7 ; // 找到 了 “ ( 未來 的  ) 左 邊界點 ” 
                                                        // 7+
​
                        node_Work_For_LeftSide -> left = nullptr ;
​
                        break ;
​
                    }
                    else if( low > node_Work_For_LeftSide -> val )
                    {
​
                        if(node_Work_For_LeftSide -> right != nullptr )
                        {
​
                            state_code_Front_For_LeftSide = 2 ;
​
                            continue ;
​
                        }
                        else
                        {
                            //右側 無  “ “ 下 一 ” 夾層 子節點 ”
                            state_code_Backward_For_LeftSide = 9 ;
                                                        // 9+
                            node_Pre_From_Work_For_LeftSide -> left = nullptr ;
                            break ;
​
                        }
​
​
​
                    }
                    else if( node_Work_For_LeftSide -> left == nullptr )
                    {
                        state_code_Backward_For_LeftSide = 8 ; // 此 下降 階段  的 結點 值  均在  左邊界  範圍  內    
                                                        // 8+
                        break ;
​
​
                    }
​
​
​
​
                }
                
​
​
​
            }
​
​
​
        }
​
​
​
        // 對 右  邊界  的  處理  /  相關 處理  
​
        TreeNode * node_Work_For_RightSide = root ;
​
        // if( root_New_For_Return != nullptr )
        // {
        //     node_Work_For_RightSide = root_New_For_Return ;
        // }
​
                                // 用 新 根 結點 ？  
        // 其它 的 地方 有 待 協調    
​
        TreeNode * node_Pre_From_Work_For_RightSide = nullptr ;
​
        int state_code_Front_For_RightSide = 0 ;
​
        // 1 右 搜  
        // 2 左 搜  
​
        int state_code_Backward_For_RightSide = 0 ;
​
​
        if(high > val_root )
        {
            state_code_Front_For_RightSide = 1 ;
​
            while(1)
            {
​
                //cout<< "node_Work_For_RightSide -> val : " << node_Work_For_RightSide -> val <<endl ;
​
                if( state_code_Front_For_RightSide == 1 )
                {
                    if( high > node_Work_For_RightSide -> val )
                    {
                        node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                        if(node_Work_For_RightSide -> right != nullptr && node_Work_For_RightSide -> val <= high )
                        {
                            node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
                        }
                        else
                        {
                            if(node_Work_For_RightSide -> right == nullptr)
                            {
                                state_code_Backward_For_RightSide = 3 ; // 二叉搜尋樹 內 的 結點 值  均在  左邊界  範圍  內    
                            
                                // 動態 處理 資料結構  
​
                                break ;
​
​
                            }
                            else if(node_Work_For_RightSide -> val > high)
                            {
​
                                node_Pre_From_Work_For_RightSide -> right = nullptr ;
​
                                break ;
​
​
                            }
                            
​
                        }
​
​
​
                    }
                    else if( high == node_Work_For_RightSide -> val )
                    {
​
                        // 結點 值  唯一 時 的 處理 
​
                        // 結點 值  不 唯一 時 的 處理  
                        // if 對 此 題 
​
                        while( node_Work_For_RightSide->right != nullptr && node_Work_For_RightSide->right->val == node_Work_For_RightSide->val )
                        {
                            node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                            node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
                        }
​
​
                        state_code_Backward_For_RightSide = 4 ; // 找到 了 “ ( 未來 的  ) 左 邊界點 ” 
                        
                        node_Work_For_RightSide -> right = nullptr ;
                        
                        break ;
​
                    }
                    else if( high < node_Work_For_RightSide -> val )
                    {
​
                        
​
                        if(node_Work_For_RightSide -> left != nullptr )
                        {
                            state_code_Front_For_RightSide = 2 ;
                            //cout<<444444444<<endl;
                            continue ;
​
                        }
                        else
                        {
                            //右側 無 “ 夾層 子節點 ”
                            state_code_Backward_For_RightSide = 5 ;
​
                            node_Pre_From_Work_For_RightSide -> right = nullptr ;
​
                            break ;
​
​
                        }
​
​
​
                    }
​
​
                }
                else if(state_code_Front_For_RightSide == 2 )
                {
                    if(node_Work_For_RightSide -> left != nullptr && node_Work_For_RightSide->val > high  )
                    {
                        // 之前 的 Pre 結點 已經 找到 了 所 需 位置 , 故 開始 保留 其 所在 位置 的 地址 / or 交 由  其它 指標 儲存 , 並 繼續 前進 ( 這裡 是 跟進  )  /  處理 + 跟進    
                        //node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide 
​
                        //cout<<444444444<<endl;
​
                        node_Work_For_RightSide = node_Work_For_RightSide -> left ;
​
                    }
                    else
                    {
                        //右側 有 “ 夾層 子節點 ”
                        if(node_Work_For_RightSide->val <= high )
                        {
                            node_Pre_From_Work_For_RightSide -> right = node_Work_For_RightSide ;
                            node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
                        }
                        else if(node_Work_For_RightSide->left == nullptr )
                        {
                            //右側 無 “ “ 所需 ” 夾層 子節點 ”
​
                            break ;
​
​
                        }
                        
​
                        if(node_Work_For_RightSide -> right != nullptr )
                        {
                            state_code_Front_For_RightSide = 3 ;
​
                            continue ;  
​
​
​
​
                        }
                        else
                        {
​
                            
                            state_code_Backward_For_RightSide = 6 ;
​
                            break ;
​
​
​
                        }
​
​
                        
​
​
                    }
​
                    // 易於 實現 的 方法  
​
                    // 維護 資料結構 執行 效率 的 方法 
​
                    // 計算機 處理 效率 / 效率 化 的 方法  
​
​
                }
                else if(state_code_Front_For_RightSide == 3 )
                {
                    // 輕量化 設計  
                    // Simple 化 設計 
                    // 要 達到 標準 
                    // 模組化 設計  支援    
​
                    //cout<<5555555<<endl;
​
                    if( node_Work_For_RightSide->right != nullptr && high > node_Work_For_RightSide -> val )
                    {
                        node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                        node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
​
​
​
                    }
                    else if( high == node_Work_For_RightSide -> val )
                    {
​
                        // 結點 值  唯一 時 的 處理 
​
                        // 結點 值  不 唯一 時 的 處理  
                        // if 對 此 題 
​
                        while( node_Work_For_RightSide->right != nullptr && node_Work_For_RightSide->right->val == node_Work_For_RightSide->val )
                        {
                            node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                            node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
                        }
​
​
                        state_code_Backward_For_RightSide = 7 ; // 找到 了 “ ( 未來 的  ) 左 邊界點 ” 
​
                        node_Work_For_RightSide -> right = nullptr ;
​
                        break ;
​
                    }
                    else if( high < node_Work_For_RightSide -> val )
                    {
​
                        if(node_Work_For_RightSide -> left != nullptr )
                        {
​
                            state_code_Front_For_RightSide = 2 ;
​
                            continue ;
​
                        }
                        else
                        {
                            //右側 無  “ “ 下 一 ” 夾層 子節點 ”
                            state_code_Backward_For_RightSide = 9 ;
​
​
                        }
​
​
​
                    }
                    else if( node_Work_For_RightSide -> right == nullptr )
                    {
                        state_code_Backward_For_RightSide = 8 ; // 此 下降 階段  的 結點 值  均在  左邊界  範圍  內    
                        
                        break ;
​
​
                    }
​
​
​
​
                }
                
​
​
​
            }
​
        }
        else if( high == val_root )
        {
            node_Work_For_RightSide = root ;
            while(node_Work_For_RightSide->right != nullptr && node_Work_For_RightSide->right->val == node_Work_For_RightSide->val )
            {
                node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
            }
​
            node_Work_For_RightSide -> right = nullptr ;
​
​
        }
        else if( high < val_root )
        {
            state_code_Front_For_RightSide = 4 ;
​
            while(1)
            {
                //cout<<111111111<<endl;
                if( state_code_Front_For_RightSide == 4 )
                {
                    if(node_Work_For_RightSide -> left != nullptr && node_Work_For_RightSide->val > high  )
                    {
                        // 之前 的 Pre 結點 已經 找到 了 所 需 位置 , 故 開始 保留 其 所在 位置 的 地址 / or 交 由  其它 指標 儲存 , 並 繼續 前進 ( 這裡 是 跟進  )  /  處理 + 跟進    
                        //node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide 
​
                        node_Work_For_RightSide = node_Work_For_RightSide -> left ;
​
                    }
                    else
                    {
                        // 更新 根 結點  
                        if(node_Work_For_RightSide->val <= high )
                        {
                            root_New_For_Return = node_Work_For_RightSide ;
​
                            node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                        }
                        else if(node_Work_For_RightSide->left == nullptr )
                        {
                            // 無 符合 要求 的 子節點  
​
                            root_New_For_Return = nullptr ;
​
                            break ;
​
​
                        }
                        
​
                        if(node_Work_For_RightSide -> right != nullptr )
                        {
                            state_code_Front_For_RightSide = 3 ;
​
                            continue ;  
​
​
​
​
                        }
                        else
                        {
​
                            
                            state_code_Backward_For_RightSide = 6 ;
​
                            break ;
​
​
​
                        }
​
​
                        
​
​
                    }
                    
​
​
                }
                else if(state_code_Front_For_RightSide == 2 )
                {
                    if(node_Work_For_RightSide -> left != nullptr && node_Work_For_RightSide->val > high  )
                    {
                        // 之前 的 Pre 結點 已經 找到 了 所 需 位置 , 故 開始 保留 其 所在 位置 的 地址 / or 交 由  其它 指標 儲存 , 並 繼續 前進 ( 這裡 是 跟進  )  /  處理 + 跟進    
                        //node_Pre_From_Work_For_LeftSide = node_Work_For_LeftSide 
​
                        node_Work_For_RightSide = node_Work_For_RightSide -> left ;
​
                    }
                    else
                    {
                        //右側 有 “ 夾層 子節點 ”
                        if(node_Work_For_RightSide->val <= high )
                        {
                            node_Pre_From_Work_For_RightSide -> right = node_Work_For_RightSide ;
                            node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
                        }
                        else if(node_Work_For_RightSide->left == nullptr )
                        {
                            //右側 無 “ “ 所需 ” 夾層 子節點 ”
​
                            break ;
​
​
                        }
                        
​
                        if(node_Work_For_RightSide -> right != nullptr )
                        {
                            state_code_Front_For_RightSide = 3 ;
​
                            continue ;  
​
​
​
​
                        }
                        else
                        {
​
                            
                            state_code_Backward_For_RightSide = 9 ;
​
                            break ;
​
​
​
                        }
​
​
                        
​
​
                    }
​
                    // 易於 實現 的 方法  
​
                    // 維護 資料結構 執行 效率 的 方法 
​
                    // 計算機 處理 效率 / 效率 化 的 方法  
​
​
                }
                else if(state_code_Front_For_RightSide == 3 )
                {
                    // 輕量化 設計  
                    // Simple 化 設計 
                    // 要 達到 標準 
                    // 模組化 設計  支援   
​
                    //cout<< "node_Work_For_RightSide -> val : " <<node_Work_For_RightSide -> val<<endl;
​
                    if( node_Work_For_RightSide->right != nullptr && high > node_Work_For_RightSide -> val )
                    {
                        node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                        node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
​
​
​
                    }
                    else if( high == node_Work_For_RightSide -> val )
                    {
​
                        // 結點 值  唯一 時 的 處理 
​
                        // 結點 值  不 唯一 時 的 處理  
                        // if 對 此 題 
​
                        while( node_Work_For_RightSide->right != nullptr && node_Work_For_RightSide->right->val == node_Work_For_RightSide->val )
                        {
                            node_Pre_From_Work_For_RightSide = node_Work_For_RightSide ;
​
                            node_Work_For_RightSide = node_Work_For_RightSide -> right ;
​
                        }
​
​
                        state_code_Backward_For_RightSide = 7 ; // 找到 了 “ ( 未來 的  ) 左 邊界點 ” 
                                                        // 7+
​
                        node_Work_For_RightSide -> right = nullptr ;
                        
                        break ;
​
                    }
                    else if( high < node_Work_For_RightSide -> val )
                    {
                        //cout<<33333333333<<endl;
                        if(node_Work_For_RightSide -> left != nullptr )
                        {
                            //cout<<33333333333<<endl;
​
                            state_code_Front_For_RightSide = 2 ;
​
                            continue ;
​
                        }
                        else
                        {
                            //cout<<33333333333<<endl;
                            //右側 無  “ “ 下 一 ” 夾層 子節點 ”
                            state_code_Backward_For_RightSide = 9 ;
                                                        // 9+
                            node_Pre_From_Work_For_RightSide -> right = nullptr ;
​
                            break ;
​
                        }
​
​
​
                    }
                    else if( node_Work_For_RightSide -> right == nullptr )
                    {
                        //cout<<33333333333<<endl;
                        state_code_Backward_For_RightSide = 8 ; // 此 下降 階段  的 結點 值  均在  左邊界  範圍  內    
                                                        // 8+
                        break ;
​
​
                    }
​
​
​
​
                }
                
​
​
​
            }
​
​
​
        }
​
        
        // 設定 有效 的 根節點    
​
        if( root_New_For_Return == nullptr )
        {
            
            
        }
        else
        {
            while(root_New_For_Return ->val < low || root_New_For_Return -> val > high )
            {
                if(root_New_For_Return ->val < low)
                {
                    if(root_New_For_Return -> right != nullptr )
                    {
                        root_New_For_Return = root_New_For_Return -> right ;
​
                    }
                    else
                    {
​
                        root_New_For_Return = nullptr ;
​
                    }
​
                }
                else if( root_New_For_Return -> val > high )
                {
                    if(root_New_For_Return -> left != nullptr )
                    {
                        root_New_For_Return = root_New_For_Return -> left ;
​
                    }
                    else
                    {
​
                        root_New_For_Return = nullptr ;
​
                    }
​
​
                }
​
​
            }
​
​
​
​
        }
​
        
​
​
        return root_New_For_Return ;
​
​
​
    }
};

108.將有序陣列轉換為二叉搜尋樹

題目連結 :

108. 將有序陣列轉換為二叉搜尋樹 - 力扣（LeetCode）

Code :

​

538.把二叉搜尋樹轉換為累加樹

題目連結 :

538. 把二叉搜尋樹轉換為累加樹 - 力扣（LeetCode）

Code :

​