Gitt en BST , er oppgaven å sette inn en ny node i denne BST .
Eksempel:
Innsetting i binært søketre
Slik setter du inn en verdi i et binært søketre:
En ny nøkkel settes alltid inn ved bladet ved å opprettholde egenskapen til det binære søketreet. Vi begynner å søke etter en nøkkel fra roten til vi treffer en bladnode. Når en bladnode er funnet, legges den nye noden til som et barn av bladnoden. Trinnene nedenfor følges mens vi prøver å sette inn en node i et binært søketre:
- Sjekk verdien som skal settes inn (f.eks X ) med verdien til gjeldende node (si val ) vi er i:
- Hvis X er mindre enn val flytt til venstre undertre.
- Ellers, flytt til høyre undertre.
- Når bladnoden er nådd, sett inn X til høyre eller venstre basert på forholdet mellom X og bladnodens verdi.
Følg illustrasjonen nedenfor for en bedre forståelse:
Illustrasjon:
Innsetting i BST
Innsetting i BST
Innsetting i BST
Innsetting i BST
Innsetting i BST
Innsetting i binært søketre ved bruk av rekursjon:
Nedenfor er implementeringen av innsettingsoperasjonen ved bruk av rekursjon.
C++14
c-streng i array
// 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->høyre = Sett inn(root->høyre, verdi);> >}> >else> if> (value data) {> >// Insert left node data, if the 'value'> >// to be inserted is smaller than 'root' node data.> >// Process left nodes.> >root->venstre = Sett inn(root->venstre, verdi);> >}> >// 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->venstre);> >cout ' '; Inorder(root->Ikke sant); } // Driverkode int main() { BST b, *root = NULL; rot = b.Sett inn(rot, 50); b.Sett inn(root, 30); b.Sett inn(root, 20); b.Sett inn(root, 40); b.Sett inn(root, 70); b.Sett inn(root, 60); b.Sett inn(root, 80); b.Inorder(root); returner 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->nøkkel = element;> >temp->venstre = temp->høyre = NULL;> >return> temp;> }> // A utility function to do inorder traversal of BST> void> inorder(>struct> node* root)> {> >if> (root != NULL) {> >inorder(root->venstre);> >printf>(>'%d '>, root->nøkkel);> >inorder(root->høyre);> >}> }> // 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->venstre = insert(node->venstre, tast);> >else> if> (key>node->nøkkel)> >node->høyre = insert(node->høyre, nøkkel);> >// 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;> }> |
>
>
Java
// 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); // Returner (uendret) nodepekeren returrot; } // Denne metoden kaller hovedsakelig InorderRec() void inorder() { inorderRec(root); } // En verktøyfunksjon for å // gjøre inorder-gjennomgang av BST void inorderRec(Noderot) { if (root != null) { inorderRec(root.left); System.out.print(root.key + ' '); inorderRec(root.right); } } // Driver Code public static void main(String[] args) { BinarySearchTree tree = new BinarySearchTree(); /* La oss lage følgende 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); // Skriv ut inorder-gjennomgang av BST-treet.inorder(); } } // Denne koden er bidratt av Ankur Narain Verma> |
tilfeldig rekkefølge sql
>
>
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); // Returner (uendret) nodepekeren returrot; } // Denne metoden kaller hovedsakelig InorderRec() void inorder() { inorderRec(root); } // En verktøyfunksjon for å // gjøre inorder-gjennomgang av BST void inorderRec(Noderot) { if (root != null) { inorderRec(root.left); Console.Write(root.key + ' '); inorderRec(root.right); } } // Driver Code public static void Main(String[] args) { BinarySearchTree tree = new BinarySearchTree(); /* La oss lage følgende 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); // Skriv ut inorder-gjennomgang av BST-treet.inorder(); } } // Denne koden er bidratt av 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); // Returner (uendret) nodepekeren returrot; } // Denne metoden kaller hovedsakelig InorderRec()-funksjonen inorder() { inorderRec(root); } // En verktøyfunksjon for å // gjøre inorder-gjennomgang av BST-funksjonen inorderRec(root) { if (root != null) { inorderRec(root.left); document.write(root.key+' '); inorderRec(root.right); } } // Driverkode /* La oss lage følgende BST 50 / 30 70 / / 20 40 60 80 */ insert(50); sett inn(30); sett inn(20); sett inn(40); sett inn(70); sett inn(60); sett inn(80); // Skriv ut inorder-gjennomgang av BST-inorder(); // Denne koden er bidratt av Rajput-Ji> |
>
>Produksjon
20 30 40 50 60 70 80>
Tidskompleksitet:
- Det verste tilfellet av tidskompleksiteten til innsatsoperasjoner er Åh) hvor h er høyden på det binære søketreet.
- I verste fall må vi kanskje reise fra roten til den dypeste bladnoden. Høyden på et skjevt tre kan bli n og tidskompleksiteten til innsettingsoperasjonen kan bli På).
Hjelpeplass: Hjelpemannen plass kompleksiteten ved innsetting i et binært søketre er O(1)
Innsetting i binært søketre ved hjelp av iterativ tilnærming:
I stedet for å bruke rekursjon, kan vi også implementere innsettingsoperasjonen iterativt ved å bruke en mens loop . Nedenfor er implementeringen ved hjelp av en while-løkke.
hva er 10 av 1 million
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> nøkkel) {> >prev = temp;> >temp = temp->venstre;> >}> >else> if> (temp->val prev = temp; temp = temp->høyre; } } if (prev->val> key) prev->left = node; else prev->right = node; } // Verktøyfunksjon for å skrive ut inorder traversal void inorder(Node* root) { Node* temp = root; stable st; while (temp != NULL || !st.empty()) { if (temp != NULL) { st.push(temp); temp = temp->venstre; } annet { temp = st.top(); st.pop(); cout ' '; temp = temp->høyre; } } } // Driverkode int main() { Node* root = NULL; insert(root, 30); insert(root, 50); insert(root, 15); insert(root, 20); insert(root, 10); insert(root, 40); insert(root, 60); // Funksjonskall for å skrive ut inorder-traversal inorder(root); returner 0; }> |
>
>
Java
// 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>nøkkel) {> >prev = temp;> >temp = temp.left;> >}> >else> if> (temp.val prev = temp; temp = temp.right; } } if (prev.val>key) prev.left = node; else prev.right = node; } // Funksjon for å skrive ut inorder-verdien public void inorder() { Node temp = root; Stabel stabel = ny stabel(); while (temp != null || !stack.isEmpty()) { if (temp != null) { stack.add(temp); temp = temp.venstre; } annet { 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>nøkkel):> >prev>=> temp> >temp>=> temp.left> >elif>(temp.val prev = temp temp = temp.right if (prev.val>key): prev.left = node else: prev.right = node # Funksjon for å skrive ut inordre-traversal av BST def inorder(self): temp = self.root stack = [] while (temp != Ingen eller ikke (len( stack) == 0)): if (temp != Ingen): stack.append(temp) temp = temp.left else: temp = stack.pop() print(str(temp.val) + ' ', end='') temp = temp.right if __name__ == '__main__': GFG.main([]) # Denne koden er bidratt av rastogik346.> |
>
>
C#
10 ml er hvor mye
// 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>nøkkel) {> >prev = temp;> >temp = temp.left;> >}> >else> if> (temp.val prev = temp; temp = temp.right; } } if (prev.val>key) prev.left = node; else prev.right = node; } // Funksjon for å skrive ut inorder-gjennomgangen til BST public void inorder() { Node temp = root; Stabel stabel = ny stabel(); while (temp != null || stack.Count != 0) { if (temp != null) { stack.Push(temp); temp = temp.venstre; } annet { temp = stack.Pop(); Console.Write(temp.val + ' '); temp = temp.right; } } } } // Denne koden er bidratt av 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>nøkkel) {> >prev = temp;> >temp = temp.left;> >}>else> if> (temp.val prev = temp; temp = temp.right; } } if (prev.val>key) prev.left = node; else prev.right = node; } // Funksjon for å skrive ut inorder-verdien inorder() { let temp = this.root; la stable = []; while (temp != null || stack.length> 0) { if (temp != null) { stack.push(temp); temp = temp.venstre; } annet { temp = stack.pop(); console.log(temp.val + ' '); temp = temp.right; } } } } la treet = ny BST(); tree.insert(30); tree.insert(50); tree.insert(15); tree.insert(20); tree.insert(10); tree.insert(40); tree.insert(60); tree.inorder(); // denne koden er bidratt av devendrasolunke> |
>
>Produksjon
10 15 20 30 40 50 60>
De tidskompleksitet av inordergjennomgang er På) , ettersom hver node besøkes én gang.
De Hjelpeplass er På) , da vi bruker en stabel til å lagre noder for rekursjon.
Relaterte linker:
- Binær søketresøkeoperasjon
- Sletting av binært søketre