📜  检查二叉树是否包含大小为K的平衡BST

📅  最后修改于: 2021-04-27 09:12:29             🧑  作者: Mango

给定二叉树和正整数K。任务是检查给定的二叉树中是否存在大小为K的平衡BST。如果存在,则打印“是”,否则打印“否”

例子:

Input: K = 4,
Below is the given Tree:
         15
       /    \
      10     26
     /  \     / \
    5   12  25  40
           /   /  \
          20  35   50
                 \
                  60
Output: Yes
Explanation: 
Subtree of the given tree with
size k is given below:
        40
       /  \
      35   50
             \
             60

Input: K = 4,
Below is the given Tree:
            18
            /  
           9    
          / \
         7   10
Output: No
Explanation:
There is no subtree of size K
which forms a balanced BT.

方法:想法是使用后订单遍历。以下是解决问题的步骤:

  1. 在给定的树上执行后遍历,并检查每个节点的BST条件,其中左子树中的最大值应小于当前,而右子树中的较小值应大于当前值。
  2. 然后检查BST是否平衡,即左右子树之间的绝对差应为0或1
  3. 然后,将值从子树返回到父树。
  4. 对所有节点执行上述步骤,并采用布尔变量ans ,该变量最初标记为false,用于检查是否存在平衡的BST。
  5. 如果找到大小为K的平衡BST,则打印“是”,否则打印“否”

下面是上述方法的实现:

C++
// C++ program for the above approach
#include 
using namespace std;
 
// A tree node
struct node {
    int data;
    node* left;
    node* right;
};
 
// Structure of temporary variable
struct minMax {
    bool isBST;
    bool balanced;
    int size;
    int hight;
    int min;
    int max;
};
 
// Function to create the node
node* createNode(int value)
{
    node* temp = new node();
    temp->left = NULL;
    temp->right = NULL;
    temp->data = value;
}
 
// Utility function to find Balanced
// BST of size k
minMax findBalancedBstUtil(node* root,
                           int k, bool& ans)
{
    // Base condition
    if (root == NULL)
        return { true, true, 0, 0,
                 INT_MAX, INT_MIN };
 
    // Temporary variable
    minMax temp;
 
    // Recursive call for left sub-tree
    minMax lsTree
        = findBalancedBstUtil(root->left,
                              k, ans);
 
    if (ans == true)
        return temp;
 
    // Recursive call for right sub-tree
    minMax rsTree
        = findBalancedBstUtil(root->right,
                              k, ans);
 
    if (ans == true)
        return temp;
 
    // Check those conditions which
    // violated the rules of BST
    if (!lsTree.isBST || !rsTree.isBST
        || lsTree.max > root->data
        || rsTree.min < root->data) {
        temp.isBST = false;
        return temp;
    }
 
    // Check whether the Bst is
    // height balanced or not
    if (abs(lsTree.hight
            - rsTree.hight)
            == 1
        || abs(lsTree.hight
               - rsTree.hight)
               == 0)
 
        temp.balanced = true;
 
    else
        temp.balanced = false;
 
    // Make the variable true
    // as sub-tree is BST
    temp.isBST = true;
 
    // Store the size
    temp.size = 1 + lsTree.size
                + rsTree.size;
 
    // Store the height
    temp.hight = max(lsTree.hight,
                     rsTree.hight)
                 + 1;
 
    // Store the minimum of BST
    temp.min = root->left != NULL
                   ? lsTree.min
                   : root->data;
 
    // Store the maximum of BST
    temp.max = root->right != NULL
                   ? rsTree.max
                   : root->data;
 
    // Condition to check whether the
    // size of Balnced BST is K or not
    if (temp.balanced == true
        && temp.size == k) {
        ans = true;
    }
 
    // Return the temporary variable
    // with updated data
    return temp;
}
 
// Function to find the Balanced
// BST of size k
string findBalancedBst(node* root,
                       int k)
{
    bool ans = false;
 
    // Utility function call
    findBalancedBstUtil(root, k, ans);
    return ans == true ? "Yes" : "No";
}
 
// Driver Code
int main()
{
    // Given Binary Tree
    node* root = createNode(15);
    root->left = createNode(10);
    root->right = createNode(26);
    root->left->left = createNode(5);
    root->left->right = createNode(12);
    root->right->left = createNode(25);
    root->right->left->left = createNode(20);
    root->right->right = createNode(40);
    root->right->right->left = createNode(35);
    root->right->right->right = createNode(50);
    root->right->right->right->right = createNode(60);
 
    int k = 4;
 
    // Function Call
    cout << findBalancedBst(root, k);
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
 
class GFG{
     
static boolean ans;
 
// A tree node
static class node
{
    int data;
    node left;
    node right;
};
 
// Structure of temporary variable
static class minMax
{
    boolean isBST;
    boolean balanced;
    int size;
    int hight;
    int min;
    int max;
     
    public minMax(boolean isBST, boolean balanced,
                  int size, int hight, int min,
                  int max)
    {
        super();
        this.isBST = isBST;
        this.balanced = balanced;
        this.size = size;
        this.hight = hight;
        this.min = min;
        this.max = max;
    }
    public minMax()
    {
        // TODO Auto-generated constructor stub
    }
};
 
// Function to create the node
static node createNode(int value)
{
    node temp = new node();
    temp.left = null;
    temp.right = null;
    temp.data = value;
    return temp;
}
 
// Utility function to find Balanced
// BST of size k
static minMax findBalancedBstUtil(node root,
                                  int k)
{
     
    // Base condition
    if (root == null)
        return new minMax(true, true, 0, 0,
                          Integer.MAX_VALUE,
                          Integer.MIN_VALUE );
 
    // Temporary variable
    minMax temp = new minMax();
 
    // Recursive call for left sub-tree
    minMax lsTree = findBalancedBstUtil(root.left,
                                        k);
 
    if (ans == true)
        return temp;
 
    // Recursive call for right sub-tree
    minMax rsTree = findBalancedBstUtil(root.right,
                                        k);
 
    if (ans == true)
        return temp;
 
    // Check those conditions which
    // violated the rules of BST
    if (!lsTree.isBST || !rsTree.isBST ||
         lsTree.max > root.data ||
         rsTree.min < root.data)
    {
        temp.isBST = false;
        return temp;
    }
 
    // Check whether the Bst is
    // height balanced or not
    if (Math.abs(lsTree.hight -
                 rsTree.hight) == 1 ||
        Math.abs(lsTree.hight -
                 rsTree.hight) == 0)
        temp.balanced = true;
         
    else
        temp.balanced = false;
 
    // Make the variable true
    // as sub-tree is BST
    temp.isBST = true;
 
    // Store the size
    temp.size = 1 + lsTree.size +
                    rsTree.size;
 
    // Store the height
    temp.hight = Math.max(lsTree.hight,
                          rsTree.hight) + 1;
 
    // Store the minimum of BST
    temp.min = root.left != null ?
               lsTree.min : root.data;
 
    // Store the maximum of BST
    temp.max = root.right != null ?
               rsTree.max : root.data;
 
    // Condition to check whether the
    // size of Balnced BST is K or not
    if (temp.balanced == true &&
            temp.size == k)
    {
        ans = true;
    }
 
    // Return the temporary variable
    // with updated data
    return temp;
}
 
// Function to find the Balanced
// BST of size k
static String findBalancedBst(node root,
                              int k)
{
    ans = false;
 
    // Utility function call
    findBalancedBstUtil(root, k);
    return ans == true ? "Yes" : "No";
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given Binary Tree
    node root = createNode(15);
    root.left = createNode(10);
    root.right = createNode(26);
    root.left.left = createNode(5);
    root.left.right = createNode(12);
    root.right.left = createNode(25);
    root.right.left.left = createNode(20);
    root.right.right = createNode(40);
    root.right.right.left = createNode(35);
    root.right.right.right = createNode(50);
    root.right.right.right.right = createNode(60);
 
    int k = 4;
 
    // Function call
    System.out.print(findBalancedBst(root, k));
}
}
 
// This code is contributed by Amit Katiyar


Python3
# Python3 program for the above approach
import sys
 
ans = False
 
# A tree node
class createNode:
     
    def __init__(self, data):
         
        self.data = data
        self.left = None
        self.right = None
 
# Structure of temporary variable
class newMinMax:
     
    def __init__(self, isBST, balanced, size,
                 height, mn, mx):
                      
        self.isBST = isBST
        self.balanced = balanced
        self.size = size
        self.height = height
        self.mn = mn
        self.mx = mx
 
# Utility function to find Balanced
# BST of size k
def findBalancedBstUtil(root, k):
     
    global ans
     
    # Base condition
    if (root == None):
        return newMinMax(True, True, 0, 0,
                         sys.maxsize,
                        -sys.maxsize - 1)
 
    # Temporary variable
    temp = newMinMax(True, True, 0, 0,
                     sys.maxsize,
                    -sys.maxsize - 1)
 
    # Recursive call for left sub-tree
    lsTree = findBalancedBstUtil(root.left, k)
 
    if (ans == True):
        return temp
 
    # Recursive call for right sub-tree
    rsTree = findBalancedBstUtil(root.right, k)
 
    if (ans == True):
        return temp
 
    # Check those conditions which
    # violated the rules of BST
    if (lsTree.isBST == False or
        rsTree.isBST == False or
        lsTree.mx > root.data or
        rsTree.mn < root.data):
        temp.isBST = False
        return temp
 
    # Check whether the Bst is
    # height balanced or not
    if (abs(lsTree.height - rsTree.height) == 1 or
        abs(lsTree.height - rsTree.height) == 0):
        temp.balanced = True
    else:
        temp.balanced = False
 
    # Make the variable true
    # as sub-tree is BST
    temp.isBST = True
 
    # Store the size
    temp.size = 1 + lsTree.size + rsTree.size
 
    # Store the height
    temp.height  = max(lsTree.height ,
                       rsTree.height) + 1
 
    # Store the minimum of BST
    if root.left != None:
        temp.mn = lsTree.mn
    else:
        temp.mn = root.data
 
    # Store the maximum of BST
    if root.right != None:
        temp.mx = rsTree.mx
    else:
        temp.mx = root.data
 
    # Condition to check whether the
    # size of Balnced BST is K or not
    if (temp.balanced == True and
        temp.size == k):
        ans = True
 
    # Return the temporary variable
    # with updated data
    return temp
 
# Function to find the Balanced
# BST of size k
def findBalancedBst(root, k):
     
    global ans
     
    # Utility function call
    findBalancedBstUtil(root, k)
    if ans == True:
        return "Yes"
    else:
        return "No"
 
# Driver Code
if __name__ == '__main__':
     
    # Given Binary Tree
    root = createNode(15)
    root.left = createNode(10)
    root.right = createNode(26)
    root.left.left = createNode(5)
    root.left.right = createNode(12)
    root.right.left = createNode(25)
    root.right.left.left = createNode(20)
    root.right.right = createNode(40)
    root.right.right.left = createNode(35)
    root.right.right.right = createNode(50)
    root.right.right.right.right = createNode(60)
 
    k = 4
 
    # Function Call
    print(findBalancedBst(root, k))
 
# This code is contributed by ipg2016107


C#
// C# program for the
// above approach
using System;
class GFG{
     
static bool ans;
 
// A tree node
public class node
{
  public int data;
  public node left;
  public node right;
};
 
// Structure of temporary
// variable
public class minMax
{
  public bool isBST;
  public bool balanced;
  public int size;
  public int hight;
  public int min;
  public int max;   
  public minMax(bool isBST, bool balanced,
                int size, int hight, int min,
                int max)
  {
    this.isBST = isBST;
    this.balanced = balanced;
    this.size = size;
    this.hight = hight;
    this.min = min;
    this.max = max;
  }
   
  public minMax()
  {
    // TODO Auto-generated constructor stub
  }
};
 
// Function to create the node
static node createNode(int value)
{
  node temp = new node();
  temp.left = null;
  temp.right = null;
  temp.data = value;
  return temp;
}
 
// Utility function to find Balanced
// BST of size k
static minMax findBalancedBstUtil(node root,
                                  int k)
{
  // Base condition
  if (root == null)
    return new minMax(true, true, 0, 0,
                      int.MaxValue,
                      int.MinValue);
 
  // Temporary variable
  minMax temp = new minMax();
 
  // Recursive call for left sub-tree
  minMax lsTree =
         findBalancedBstUtil(root.left, k);
 
  if (ans == true)
    return temp;
 
  // Recursive call for right sub-tree
  minMax rsTree =
         findBalancedBstUtil(root.right, k);
 
  if (ans == true)
    return temp;
 
  // Check those conditions which
  // violated the rules of BST
  if (!lsTree.isBST || !rsTree.isBST ||
      lsTree.max > root.data ||
      rsTree.min < root.data)
  {
    temp.isBST = false;
    return temp;
  }
 
  // Check whether the Bst is
  // height balanced or not
  if (Math.Abs(lsTree.hight -
               rsTree.hight) == 1 ||
      Math.Abs(lsTree.hight -
               rsTree.hight) == 0)
    temp.balanced = true;
 
  else
    temp.balanced = false;
 
  // Make the variable true
  // as sub-tree is BST
  temp.isBST = true;
 
  // Store the size
  temp.size = 1 + lsTree.size +
                  rsTree.size;
 
  // Store the height
  temp.hight = Math.Max(lsTree.hight,
                        rsTree.hight) + 1;
 
  // Store the minimum of BST
  temp.min = root.left != null ?
             lsTree.min : root.data;
 
  // Store the maximum of BST
  temp.max = root.right != null ?
             rsTree.max : root.data;
 
  // Condition to check whether the
  // size of Balnced BST is K or not
  if (temp.balanced == true &&
      temp.size == k)
  {
    ans = true;
  }
 
  // Return the temporary
  // variable with updated data
  return temp;
}
 
// Function to find the Balanced
// BST of size k
static String findBalancedBst(node root,
                              int k)
{
  ans = false;
 
  // Utility function call
  findBalancedBstUtil(root, k);
  return ans == true ? "Yes" : "No";
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given Binary Tree
  node root = createNode(15);
  root.left = createNode(10);
  root.right = createNode(26);
  root.left.left = createNode(5);
  root.left.right = createNode(12);
  root.right.left = createNode(25);
  root.right.left.left = createNode(20);
  root.right.right = createNode(40);
  root.right.right.left = createNode(35);
  root.right.right.right = createNode(50);
  root.right.right.right.right = createNode(60);
 
  int k = 4;
 
  // Function call
  Console.Write(findBalancedBst(root, k));
}
}
 
// This code is contributed by Princi Singh


输出:
Yes









时间复杂度: O(N)
辅助空间: O(1)