Vzhledem k a BST , úkolem je vložit nový uzel do tohoto BST .
Příklad:
Vložení do binárního vyhledávacího stromu
Jak vložit hodnotu do stromu binárního vyhledávání:
Nový klíč je vždy vložen na list zachováním vlastnosti binárního vyhledávacího stromu. Začneme hledat klíč od kořene, dokud nenarazíme na listový uzel. Jakmile je nalezen listový uzel, nový uzel je přidán jako potomek listového uzlu. Při pokusu o vložení uzlu do binárního vyhledávacího stromu následují následující kroky:
- Zkontrolujte hodnotu, kterou chcete vložit (např X ) s hodnotou aktuálního uzlu (řekněme val ) jsme v:
- Li X je méně než val přesunout do levého podstromu.
- V opačném případě přejděte do pravého podstromu.
- Jakmile dosáhnete uzlu listu, vložte X napravo nebo nalevo podle vztahu mezi X a hodnotu listového uzlu.
Pro lepší pochopení postupujte podle níže uvedeného obrázku:
Ilustrace:
Vložení do BST
Vložení do BST
Vložení do BST
Vložení do BST
Vložení do BST
Vložení do stromu binárního vyhledávání pomocí rekurze:
Níže je uvedena implementace operace vkládání pomocí rekurze.
C++14
rosomák vs jezevec
// C++ program to demonstrate insertion> // in a BST recursively> #include> using> namespace> std;> class> BST {> >int> data;> >BST *left, *right;> public>:> >// Default constructor.> >BST();> >// Parameterized constructor.> >BST(>int>);> >// Insert function.> >BST* Insert(BST*,>int>);> >// Inorder traversal.> >void> Inorder(BST*);> };> // Default Constructor definition.> BST::BST()> >: data(0)> >, left(NULL)> >, right(NULL)> {> }> // Parameterized Constructor definition.> BST::BST(>int> value)> {> >data = value;> >left = right = NULL;> }> // Insert function definition.> BST* BST::Insert(BST* root,>int> value)> {> >if> (!root) {> >// Insert the first node, if root is NULL.> >return> new> BST(value);> >}> >// Insert data.> >if> (value>root->data) {> >// Insert right node data, if the 'value'> >// to be inserted is greater than 'root' node data.> >// Process right nodes.> >root->right = Insert(root->right, value);> >}> >else> if> (value data) {> >// Insert left node data, if the 'value'> >// to be inserted is smaller than 'root' node data.> >// Process left nodes.> >root->left = Insert(root->left, value);> >}> >// Return 'root' node, after insertion.> >return> root;> }> // Inorder traversal function.> // This gives data in sorted order.> void> BST::Inorder(BST* root)> {> >if> (!root) {> >return>;> >}> >Inorder(root->vlevo);> >cout ' '; Inorder(root->že jo); } // Kód ovladače int main() { BST b, *root = NULL; root = b.Insert(kořen, 50); b.Vložit(kořen, 30); b.Vložit(kořen, 20); b.Vložit(kořen, 40); b.Vložit(kořen, 70); b.Vložit(kořen, 60); b.Vložit(kořen, 80); b.Inorder(kořen); návrat 0; }> |
>
>
C
// C program to demonstrate insert> // operation in binary> // search tree.> #include> #include> struct> node {> >int> key;> >struct> node *left, *right;> };> // A utility function to create a new BST node> struct> node* newNode(>int> item)> {> >struct> node* temp> >= (>struct> node*)>malloc>(>sizeof>(>struct> node));> >temp->klíč = položka;> >temp->vlevo = teplota->vpravo = NULL;> >return> temp;> }> // A utility function to do inorder traversal of BST> void> inorder(>struct> node* root)> {> >if> (root != NULL) {> >inorder(root->vlevo);> >printf>(>'%d '>, root->klíč);> >inorder(root->vpravo);> >}> }> // A utility function to insert> // a new node with given key in BST> struct> node* insert(>struct> node* node,>int> key)> {> >// If the tree is empty, return a new node> >if> (node == NULL)> >return> newNode(key);> >// Otherwise, recur down the tree> >if> (key key)> >node->left = insert(uzel->left, key);> >else> if> (key>uzel->klíč)> >node->right = insert(uzel->right, key);> >// Return the (unchanged) node pointer> >return> node;> }> // Driver Code> int> main()> {> >/* Let us create following BST> >50> >/> >30 70> >/ /> >20 40 60 80 */> >struct> node* root = NULL;> >root = insert(root, 50);> >insert(root, 30);> >insert(root, 20);> >insert(root, 40);> >insert(root, 70);> >insert(root, 60);> >insert(root, 80);> >// Print inorder traversal of the BST> >inorder(root);> >return> 0;> }> |
>
>
Jáva
// Java program to demonstrate> // insert operation in binary> // search tree> import> java.io.*;> public> class> BinarySearchTree {> >// Class containing left> >// and right child of current node> >// and key value> >class> Node {> >int> key;> >Node left, right;> >public> Node(>int> item)> >{> >key = item;> >left = right =>null>;> >}> >}> >// Root of BST> >Node root;> >// Constructor> >BinarySearchTree() { root =>null>; }> >BinarySearchTree(>int> value) { root =>new> Node(value); }> >// This method mainly calls insertRec()> >void> insert(>int> key) { root = insertRec(root, key); }> >// A recursive function to> >// insert a new key in BST> >Node insertRec(Node root,>int> key)> >{> >// If the tree is empty,> >// return a new node> >if> (root ==>null>) {> >root =>new> Node(key);> >return> root;> >}> >// Otherwise, recur down the tree> >else> if> (key root.left = insertRec(root.left, key); else if (key>root.key) root.right = insertRec(root.right, key); // Vrátí (nezměněný) ukazatel uzlu return root; } // Tato metoda volá hlavně InorderRec() void inorder() { inorderRec(root); } // Obslužná funkce pro // procházení BST void inorderRec(kořen uzlu) { if (kořen != null) { inorderRec(root.left); System.out.print(root.key + ' '); inorderRec(root.right); } } // Kód ovladače public static void main(String[] args) { BinarySearchTree tree = new BinarySearchTree(); /* Vytvořme následující BST 50 / 30 70 / / 20 40 60 80 */ tree.insert(50); tree.insert(30); tree.insert(20); tree.insert(40); tree.insert(70); tree.insert(60); tree.insert(80); // Vytiskne procházení BST stromu.inorder(); } } // Tento kód přidal Ankur Narain Verma> |
js načtení
>
>
Python3
# Python program to demonstrate> # insert operation in binary search tree> # A utility class that represents> # an individual node in a BST> class> Node:> >def> __init__(>self>, key):> >self>.left>=> None> >self>.right>=> None> >self>.val>=> key> # A utility function to insert> # a new node with the given key> def> insert(root, key):> >if> root>is> None>:> >return> Node(key)> >else>:> >if> root.val>=>=> key:> >return> root> >elif> root.val root.right = insert(root.right, key) else: root.left = insert(root.left, key) return root # A utility function to do inorder tree traversal def inorder(root): if root: inorder(root.left) print(root.val, end=' ') inorder(root.right) # Driver program to test the above functions if __name__ == '__main__': # Let us create the following BST # 50 # / # 30 70 # / / # 20 40 60 80 r = Node(50) r = insert(r, 30) r = insert(r, 20) r = insert(r, 40) r = insert(r, 70) r = insert(r, 60) r = insert(r, 80) # Print inorder traversal of the BST inorder(r)> |
>
>
C#
// C# program to demonstrate> // insert operation in binary> // search tree> using> System;> class> BinarySearchTree {> >// Class containing left and> >// right child of current node> >// and key value> >public> class> Node {> >public> int> key;> >public> Node left, right;> >public> Node(>int> item)> >{> >key = item;> >left = right =>null>;> >}> >}> >// Root of BST> >Node root;> >// Constructor> >BinarySearchTree() { root =>null>; }> >BinarySearchTree(>int> value) { root =>new> Node(value); }> >// This method mainly calls insertRec()> >void> insert(>int> key) { root = insertRec(root, key); }> >// A recursive function to insert> >// a new key in BST> >Node insertRec(Node root,>int> key)> >{> >// If the tree is empty,> >// return a new node> >if> (root ==>null>) {> >root =>new> Node(key);> >return> root;> >}> >// Otherwise, recur down the tree> >if> (key root.left = insertRec(root.left, key); else if (key>root.key) root.right = insertRec(root.right, key); // Vrátí (nezměněný) ukazatel uzlu return root; } // Tato metoda volá hlavně InorderRec() void inorder() { inorderRec(root); } // Obslužná funkce pro // procházení BST void inorderRec(kořen uzlu) { if (kořen != null) { inorderRec(root.left); Console.Write(root.key + ' '); inorderRec(root.right); } } // Kód ovladače public static void Main(String[] args) { BinarySearchTree tree = new BinarySearchTree(); /* Vytvořme následující BST 50 / 30 70 / / 20 40 60 80 */ tree.insert(50); tree.insert(30); tree.insert(20); tree.insert(40); tree.insert(70); tree.insert(60); tree.insert(80); // Vytiskne procházení BST stromu.inorder(); } } // Tento kód přispěl aashish1995> |
>
>
Javascript
> // javascript program to demonstrate> // insert operation in binary> // search tree> >/*> >* Class containing left and right child of current node and key value> >*/> >class Node {> > constructor(item) {> >this>.key = item;> >this>.left =>this>.right =>null>;> >}> >}> >// Root of BST> >var> root =>null>;> >// This method mainly calls insertRec()> >function> insert(key) {> >root = insertRec(root, key);> >}> >// A recursive function to insert a new key in BST> >function> insertRec(root, key) {> >// If the tree is empty, return a new node> >if> (root ==>null>) {> >root =>new> Node(key);> >return> root;> >}> >// Otherwise, recur down the tree> >if> (key root.left = insertRec(root.left, key); else if (key>root.key) root.right = insertRec(root.right, key); // Vrátí (nezměněný) ukazatel uzlu return root; } // Tato metoda volá hlavně funkci InorderRec() inorder() { inorderRec(root); } // Obslužná funkce pro // procházení funkcí BST inorderRec(root) { if (root != null) { inorderRec(root.left); document.write(root.key+' '); inorderRec(root.right); } } // Kód ovladače /* Vytvořme následující BST 50 / 30 70 / / 20 40 60 80 */ insert(50); vložku (30); insert(20); insert(40); insert(70); vložku (60); insert(80); // Vytiskne průchod BST inorder(); // Tento kód přispěl Rajput-Ji> |
>
>Výstup
20 30 40 50 60 70 80>
Časová náročnost:
- Nejhorším případem je časová složitost operací vkládání Ach) kde h je výška binárního vyhledávacího stromu.
- V nejhorším případě možná budeme muset cestovat od kořene k nejhlubšímu listovému uzlu. Výška zkoseného stromu se může stát n a může se stát časová složitost operace vkládání Na).
Pomocný prostor: Pomocník prostorová složitost vkládání do binárního vyhledávacího stromu je O(1)
Vkládání do stromu binárního vyhledávání pomocí iterativního přístupu:
Místo použití rekurze můžeme také implementovat operaci vkládání iterativně pomocí a zatímco smyčka . Níže je implementace pomocí smyčky while.
liška vs vlk
C++
// C++ Code to insert node and to print inorder traversal> // using iteration> #include> using> namespace> std;> // BST Node> class> Node {> public>:> >int> val;> >Node* left;> >Node* right;> >Node(>int> val)> >: val(val)> >, left(NULL)> >, right(NULL)> >{> >}> };> // Utility function to insert node in BST> void> insert(Node*& root,>int> key)> {> >Node* node =>new> Node(key);> >if> (!root) {> >root = node;> >return>;> >}> >Node* prev = NULL;> >Node* temp = root;> >while> (temp) {> >if> (temp->val> klíč) {> >prev = temp;> >temp = temp->vlevo;> >}> >else> if> (temp->val prev = teplota; temp = teplota->pravá; } } if (prev->val> key) prev->left = uzel; else prev->right = uzel; } // Obslužná funkce pro tisk procházení pořadí void inorder(Uzel* root) { Uzel* temp = root; stack st; while (temp != NULL || !st.empty()) { if (temp != NULL) { st.push(temp); temp = temp->left; } else { temp = st.top(); st.pop(); cout ' '; temp = teplota->pravá; } } } // Kód ovladače int main() { Uzel* root = NULL; insert(kořen, 30); insert(kořen, 50); insert(kořen, 15); insert(kořen, 20); insert(kořen, 10); insert(kořen, 40); insert(kořen, 60); // Volání funkce pro tisk inorder traversal inorder(root); návrat 0; }> |
>
>
Jáva
// Java code to implement the insertion> // in binary search tree> import> java.io.*;> import> java.util.*;> class> GFG {> >// Driver code> >public> static> void> main(String[] args)> >{> >BST tree =>new> BST();> >tree.insert(>30>);> >tree.insert(>50>);> >tree.insert(>15>);> >tree.insert(>20>);> >tree.insert(>10>);> >tree.insert(>40>);> >tree.insert(>60>);> >tree.inorder();> >}> }> class> Node {> >Node left;> >int> val;> >Node right;> >Node(>int> val) {>this>.val = val; }> }> class> BST {> >Node root;> >// Function to insert a key> >public> void> insert(>int> key)> >{> >Node node =>new> Node(key);> >if> (root ==>null>) {> >root = node;> >return>;> >}> >Node prev =>null>;> >Node temp = root;> >while> (temp !=>null>) {> >if> (temp.val>klíč) {> >prev = temp;> >temp = temp.left;> >}> >else> if> (temp.val prev = temp; temp = temp.right; } } if (prev.val>key) prev.left = uzel; else prev.right = uzel; } // Funkce pro tisk hodnoty inorder public void inorder() { Node temp = root; Stack stack = new Stack(); while (temp != null || !stack.isEmpty()) { if (temp != null) { stack.add(temp); temp = temp.left; } else { temp = stack.pop(); System.out.print(temp.val + ' '); temp = temp.right; } } } }> |
>
>
Python3
# Python 3 code to implement the insertion> # operation iteratively> class> GFG:> >@staticmethod> >def> main(args):> >tree>=> BST()> >tree.insert(>30>)> >tree.insert(>50>)> >tree.insert(>15>)> >tree.insert(>20>)> >tree.insert(>10>)> >tree.insert(>40>)> >tree.insert(>60>)> >tree.inorder()> class> Node:> >left>=> None> >val>=> 0> >right>=> None> >def> __init__(>self>, val):> >self>.val>=> val> class> BST:> >root>=> None> ># Function to insert a key in the BST> >def> insert(>self>, key):> >node>=> Node(key)> >if> (>self>.root>=>=> None>):> >self>.root>=> node> >return> >prev>=> None> >temp>=> self>.root> >while> (temp !>=> None>):> >if> (temp.val>klíč):> >prev>=> temp> >temp>=> temp.left> >elif>(temp.val prev = temp temp = temp.right if (prev.val>key): prev.left = node else: prev.right = node # Funkce pro tisk procházení pořadí BST def inorder(self): temp = self.root stack = [] while (temp != None or not (len( stack) == 0)): if (temp != None): stack.append(temp) temp = temp.left else: temp = stack.pop() print(str(temp.val) + ' ', end='') temp = temp.right if __name__ == '__main__': GFG.main([]) # Tento kód přispěl rastogik346.> |
>
>
C#
fizzbuzz java
// Function to implement the insertion> // operation iteratively> using> System;> using> System.Collections.Generic;> public> class> GFG {> >// Driver code> >public> static> void> Main(String[] args)> >{> >BST tree =>new> BST();> >tree.insert(30);> >tree.insert(50);> >tree.insert(15);> >tree.insert(20);> >tree.insert(10);> >tree.insert(40);> >tree.insert(60);> >// Function call to print the inorder traversal> >tree.inorder();> >}> }> public> class> Node {> >public> Node left;> >public> int> val;> >public> Node right;> >public> Node(>int> val) {>this>.val = val; }> }> public> class> BST {> >public> Node root;> >// Function to insert a new key in the BST> >public> void> insert(>int> key)> >{> >Node node =>new> Node(key);> >if> (root ==>null>) {> >root = node;> >return>;> >}> >Node prev =>null>;> >Node temp = root;> >while> (temp !=>null>) {> >if> (temp.val>klíč) {> >prev = temp;> >temp = temp.left;> >}> >else> if> (temp.val prev = temp; temp = temp.right; } } if (prev.val>key) prev.left = uzel; else prev.right = uzel; } // Funkce pro tisk průjezdu pořadím BST public void inorder() { Node temp = root; Stack stack = new Stack(); while (temp != null || stack.Count != 0) { if (temp != null) { stack.Push(temp); temp = temp.left; } else { temp = stack.Pop(); Console.Write(temp.val + ' '); temp = temp.right; } } } } // Tento kód přispěl Rajput-Ji> |
>
>
Javascript
// JavaScript code to implement the insertion> // in binary search tree> class Node {> >constructor(val) {> >this>.left =>null>;> >this>.val = val;> >this>.right =>null>;> >}> }> class BST {> >constructor() {> >this>.root =>null>;> >}> >// Function to insert a key> >insert(key) {> >let node =>new> Node(key);> >if> (>this>.root ==>null>) {> >this>.root = node;> >return>;> >}> >let prev =>null>;> >let temp =>this>.root;> >while> (temp !=>null>) {> >if> (temp.val>klíč) {> >prev = temp;> >temp = temp.left;> >}>else> if> (temp.val prev = temp; temp = temp.right; } } if (prev.val>key) prev.left = uzel; else prev.right = uzel; } // Funkce pro tisk inorder hodnoty inorder() { let temp = this.root; nech stack = []; while (temp != null || stack.length> 0) { if (temp != null) { stack.push(temp); temp = temp.left; } else { temp = stack.pop(); console.log(temp.val + ' '); temp = temp.right; } } } } let tree = new BST(); tree.insert(30); tree.insert(50); tree.insert(15); tree.insert(20); tree.insert(10); tree.insert(40); tree.insert(60); tree.inorder(); // tento kód přispěl devendrasolunke> |
>
>Výstup
10 15 20 30 40 50 60>
The časovou složitost z nepořádkový průchod je Na) , protože každý uzel je navštíven jednou.
The Pomocný prostor je Na) , protože používáme zásobník k ukládání uzlů pro rekurzi.
Související odkazy:
- Binární vyhledávací strom vyhledávací operace
- Operace odstranění binárního vyhledávacího stromu