ביינערי זוכן בוים ויסמעקן אָפּעראַציע  


שוועריקייט לעוועל שווער
אָפט געבעטן אין אַקקאָליטע אַמאַזאָן קוואַלקאַם סאַמסונג
ביינערי זוכן בוים ביינערי טרי בוים

פּראָבלעם סטאַטעמענט  

די פּראָבלעם "ביינערי זוכן בוים ויסמעקן אָפּעראַציע" פרעגט אונדז צו ינסטרומענט די ויסמעקן אָפּעראַציע פֿאַר ביינערי זוכן בוים. דיליט פונקציע רעפערס צו די פאַנגקשאַנאַליטי צו ויסמעקן אַ נאָדע מיט אַ געגעבן שליסל / דאַטן.

בייַשפּיל  

אַרייַנשרייַב

ביינערי זוכן בוים ויסמעקן אָפּעראַציעשפּילקע

נאָדע צו ווערן אויסגעמעקט = 5

רעזולטאַט

שפּילקע

צוגאַנג פֿאַר ביינערי זוכן בוים ויסמעקן אָפּעראַציע  

אַזוי ווען מיר רעדן וועגן דיליטינג אַ נאָדע פֿון אַ ביינערי זוכן בוים. איין זאַך צו טאָן איז ווען מיר ויסמעקן אַ נאָדע, אַלע די פּראָפּערטיעס פון BST מוזן זיין צופֿרידן. אויב מיר רימוווינג אַ ינערלעך נאָדע, מיר דאַרפֿן צו מאַכן זיכער אַז סאַבסטרי צוזאַמען מיט די נייַע שורש סאַטיספייז די פּראָפּערטיעס פון בסט.

איצט מיר האָבן דריי קאַסעס צו האַנדלען מיט. די קאַסעס זענען באזירט אויף די נומער פון קינדער אַ נאָדע. און צו ענטפֿערן די קשיא פארוואס קאַטאַגערייז די נאָודז לויט די נומער פון קינדער? אַזוי, עס איז גרינגער צו האַנדלען מיט אַ פירן און אַ נאָדע מיט איין קינד. אַזוי לאָזן ס דיסקוטירן אַלע די דריי קאַסעס בעקיצער.

  1. נאָדע אָן קינד (בלאַט)
  2. נאָדע מיט איין קינד
  3. נאָדע מיט צוויי קינדער

אויב די נאָדע איז אַ בלאַט, מיר קענען נאָר באַזייַטיקן די נאָדע פון ​​דעם בוים. די אָפּעראַציע קען נישט רעזולטאַט אין הילעל פון קיין פון די BST פּראָפּערטיעס. איצט אויב מיר באַטראַכטן די פאַל פון איין קינד. מיר קענען פשוט באַזייַטיקן די נאָדע און שטעלן זיין קינד אין דעם אָרט. דער בלויז פּראָבלעם ערייזאַז ווען מיר פּרובירן צו באַזייַטיקן אַ נאָדע מיט צוויי קינדער.

צו באַזייַטיקן אַ נאָדע מיט צוויי קינדער, ערשטער מיר געפֿינען די ינאָרדער סאַקסעסער פון דעם נאָדע. שטעלן די סאַקסעסער אין דעם אָרט פון די אַוועקגענומען נאָדע. ווי אַזוי קענען מיר גאַראַנטירן אַז די רימוווינג פון די סאַקסעסער קען נישט אָנרירן די BST פּראָפּערטיעס? מיר קענען גאַראַנטירן דאָס ווייַל אַ נאָדע וואָס כאַפּאַנז צו זיין סאַקסעסער קען קיינמאָל האָבן צוויי קינדער. אָדער עס וועט האָבן איין קינד אָדער קיין קינד. אויב די סאַקסעסער רימוווינג, די BST פּראָפּערטיעס וועט נישט אָנרירן. 

קאָדעקס  

C ++ קאָד פֿאַר ביינערי זוכן בוים ויסמעקן אָפּעראַציע

#include<bits/stdc++.h>
using namespace std;

struct node
{
    int data;
    node *left, *right;
};

node* create(int data){
  node* tmp = new node();
  tmp->data = data;
  tmp->left = tmp->right = NULL;
}

void inorder(node* root){
  if(root){
    inorder(root->left);
    cout<<root->data<<" ";
    inorder(root->right);
  }
}

// return the node which is in the most left direction of root
// the smallest node in the entire subtree rooted at current node
node* minNode(node* root)
{
  node* tmp = root;
  while(tmp && tmp->left)
    tmp = tmp->left;
  return tmp;
}

// deleted the node with given data from tree
node* deleteNode(node* root, int data)
{
  // if current node is empty return current node(NULL)
  if(!root) return root;

  	// node to be deleted is in left sub-tree
    if (data < root->data)
        root->left = deleteNode(root->left, data);
  	// node to be deleted in right sub-tree
    else if (data > root->data)
        root->right = deleteNode(root->right, data);
    // current node is node to be deleted
    else
    {
        // Case 1 + Case 2
        // if left is null this means that it is either of the two cases
        if (root->left == NULL)
        {
            node* tmp = root->right;
            free(root);
            return tmp;
        }
        // Case 2 node has a left child but not right child
        // thus it has only a single child
        else if (root->right == NULL)
        {
            node* tmp = root->left;
            free(root);
            return tmp;
        }
  		// Case 3
  		// first find the successor
  		// successor is the element which comes next in inorder traversal of BST
  		// so it is the node in most left direction in right sub-tree
        node *successor = minNode(root->right);
        // place successor in place of current node
        root->data = successor->data;
        // now simply delete the successor from root's right child
        root->right = deleteNode(root->right, successor->data);
    }
    return root;
}

int main()
{
  node* root = create(7);
  root->left = create(5);
  root->right = create(8);
  root->left->left = create(3);
  root->left->left->right = create(4);
  root->left->right = create(6);
  cout<<"current inorder traversal of tree"<<endl;
  inorder(root);
  cout<<endl;
  root = deleteNode(root, 5);
  cout<<"inorder traversal after deleting node with value 5"<<endl;
  inorder(root);
  cout<<endl;
    return 0;
}
current inorder traversal of tree
3 4 5 6 7 8
inorder traversal after deleting node with value 5
3 4 6 7 8

Java קאָד פֿאַר ביינערי זוכן בוים ויסמעקן אָפּעראַציע

import java.util.*;
// Class that denotes a node of the tree
class node
{ 
    int data; 
    node left, right, random; 
  
    public node(int data) 
    { 
        this.data = data;
        left = right = random = null; 
    } 
}

class Tree 
{ 
    static node root;
  static node create(int data) {
    node tmp = new node(data);
    return tmp;
  }

  static void inorder(node root){
    if(root != null){
      inorder(root.left);
      System.out.print(root.data + " ");
      inorder(root.right);
    }
  }

  // return the node which is in the most left direction of root
  // the smallest node in the entire subtree rooted at current node
  static node minNode(node root) 
  {
    node tmp = root;
    while(tmp != null && tmp.left != null)
      tmp = tmp.left;
    return tmp;
  }
    
  // deleted the node with given data from tree
  static node deleteNode(node root, int data) 
  {
    // if current node is empty return current node(NULL)
    if(root == null) return root;
    	// node to be deleted is in left sub-tree
      if (data < root.data)
          root.left = deleteNode(root.left, data); 
    	// node to be delted in right sub-tree
      else if (data > root.data) 
          root.right = deleteNode(root.right, data); 
      // current node is node to be deleted
      else
      { 
          // Case 1 + Case 2
          // if left is null this means that it is either of the two cases
          if (root.left == null) 
          { 
              return root.right;
          } 
          // Case 2 node has a left child but not right child
          // thus it has only a single child
          else if (root.right == null)
          { 
              return root.left;
          }
    		// Case 3
    		// first find the successor
    		// successor is the element which comes next in inorder traversal of BST
    		// so it is the node in most left direction in right sub-tree
          node successor = minNode(root.right);
          // place successor in place of current node
          root.data = successor.data;
          // now simply delete the successor from root's right child
          root.right = deleteNode(root.right, successor.data); 
      } 
      return root; 
  }

  public static void main(String[] args) 
  {
    root = create(7);
    root.left = create(5);
    root.right = create(8);
    root.left.left = create(3);
    root.left.left.right = create(4);
    root.left.right = create(6);
    System.out.println("current inorder traversal of tree");
    inorder(root);
    System.out.println();
    root = deleteNode(root, 5);
    System.out.println("inorder traversal after deleting node with value 5");
    inorder(root);
    System.out.println();
  }
}
current inorder traversal of tree
3 4 5 6 7 8 
inorder traversal after deleting node with value 5
3 4 6 7 8 

קאַמפּלעקסיטי אַנאַליסיס  

צייט קאַמפּלעקסיטי

אָ (N), פֿאַר דיליטינג. באַטראַכטן אַז איר דאַרפֿן צו ויסמעקן די וואָרצל פון דעם בוים וואָס האט לינקס און רעכט קינדער. און די רעכט קינדער איז אַ סקיוד בוים אין לינקס ריכטונג נאָך די באַלדיק רעכט קינד פון וואָרצל. דעריבער, דאָס ויסמעקן די אָפּעראַציע צו לויפן אין לינעאַר צייט קאַמפּלעקסיטי.

זע אויך
דרך סאַם

ספעיס קאַמפּלעקסיטי

אָ (1), בעשאַס ויסמעקן אָפּעראַציע. מיר האָבן ניט סטאָרד קיין אינפֿאָרמאַציע און אַזוי די אַלגערידאַם איז קעסיידערדיק פּלאַץ.

די אַקיומיאַליישאַן פון דעם אויבן צוגאַנג יגזיסץ, אָבער עס נעמט אויך O (N) צייט. מיר קענען פירן אַן ינאָרדער טראַווערסאַל און ראַטעווען עלטערן פון יעדער נאָדע. אין דעם וועג, ווען מיר דאַרפֿן צו ויסמעקן די סאַקסעסער, מיר פשוט פאַרבייַטן די פאָטער 'ס לינקס אָדער רעכט קינד צו נאַל אַקאָרדינגלי. אָבער דער צוגאַנג וועט נעמען O (N) פּלאַץ און וועט נישט ווירקן די קאַמפּלעקסיטי אין די ערגסט פאַל.