We hebben het al besproken Binaire binaire boom met schroefdraad .
Het invoegen in een binaire boom met schroefdraad is vergelijkbaar met het invoegen in een binaire boom, maar we zullen de threads moeten aanpassen na het invoegen van elk element.
C-weergave van binair schroefdraadknooppunt:
struct Node { struct Node *left *right; int info; // false if left pointer points to predecessor // in Inorder Traversal boolean lthread; // false if right pointer points to successor // in Inorder Traversal boolean rthread; }; In de volgende uitleg hebben we erover nagedacht Binaire zoekboom (BST) voor invoeging aangezien invoeging wordt gedefinieerd door enkele regels in BST's.
Laten tmp het nieuw ingevoegde knooppunt zijn . Er kunnen drie gevallen zijn tijdens het inbrengen:
Geval 1: Invoeging in lege boom
Zowel de linker- als de rechteraanwijzer van tmp worden ingesteld op NULL en het nieuwe knooppunt wordt de root.
methode substring java
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
Geval 2: Wanneer er een nieuw knooppunt wordt ingevoegd als het linkerkind
Nadat we het knooppunt op de juiste plaats hebben geplaatst, moeten we ervoor zorgen dat de linker- en rechterdraad naar respectievelijk de voorganger en de opvolger wijzen. Het knooppunt dat was inorde opvolger . Dus de linker- en rechterdraad van het nieuwe knooppunt zullen zijn-
sorteer-java samenvoegen
tmp -> left = par ->left; tmp -> right = par;
Vóór het invoegen was de linkeraanwijzer van de ouder een thread, maar na het invoegen zal het een link zijn die naar het nieuwe knooppunt wijst.
par -> lthread = false; par -> left = temp;
Het volgende voorbeeld laat zien dat een knooppunt wordt ingevoegd als het linkerkind van zijn ouder.
Na plaatsing van 13
map hernoemen in linux
Voorganger van 14 wordt de voorloper van 13 dus links draad van 13 punten naar 10.
Opvolger van 13 is 14 dus rechtse draad van 13 wijst naar linkerkind wat 13 is.
De linkerwijzer van 14 is geen draad, maar wijst naar het linkerkind, dat 13 is.
Geval 3: Wanneer een nieuw knooppunt als het juiste kind wordt ingevoegd
De ouder van tmp is zijn inorde-voorganger. Het knooppunt dat in volgorde de opvolger was van de ouder, is nu de in volgorde opvolger van dit knooppunt tmp. Dus de linker- en rechterdraad van het nieuwe knooppunt zullen zijn-
tmp -> left = par; tmp -> right = par -> right;
Vóór het invoegen was de rechteraanwijzer van de ouder een thread, maar na het invoegen zal het een link zijn die naar het nieuwe knooppunt wijst.
mylivecricket alternatief
par -> rthread = false; par -> right = tmp;
Het volgende voorbeeld laat zien dat een knooppunt wordt ingevoegd als het rechterkind van zijn ouder.
Na 15 ingevoegd
Opvolger van 14 wordt opvolger van 15 dus rechtse draad van 15 punten naar 16
Voorganger van 15 is 14 dus linkerdraad van 15 punten naar 14.
De rechterwijzer van 14 is geen draad, maar wijst naar het rechterkind, dat 15 is.
Java-escape-teken
C++-implementatie om een nieuw knooppunt in te voegen in de Threaded Binary Search Tree:
Leuk vinden standaard BST-inzetstuk we zoeken naar de sleutelwaarde in de boom. Als de sleutel al aanwezig is, keren we terug, anders wordt de nieuwe sleutel ingevoegd op het punt waar het zoeken eindigt. Bij BST eindigt het zoeken wanneer we de sleutel vinden of wanneer we een NULL-linker- of rechterwijzer bereiken. Hier worden alle linker en rechter NULL-aanwijzers vervangen door threads, behalve de linkeraanwijzer van het eerste knooppunt en de rechteraanwijzer van het laatste knooppunt. Dus hier zal het zoeken niet succesvol zijn als we een NULL-aanwijzer of een thread bereiken.
Uitvoering:
C++// Insertion in Threaded Binary Search Tree. #include
// Java program Insertion in Threaded Binary Search Tree. import java.util.*; public class solution { static class Node { Node left right; int info; // False if left pointer points to predecessor // in Inorder Traversal boolean lthread; // False if right pointer points to successor // in Inorder Traversal boolean rthread; }; // Insert a Node in Binary Threaded Tree static Node insert( Node root int ikey) { // Searching for a Node with given value Node ptr = root; Node par = null; // Parent of key to be inserted while (ptr != null) { // If key already exists return if (ikey == (ptr.info)) { System.out.printf('Duplicate Key !n'); return root; } par = ptr; // Update parent pointer // Moving on left subtree. if (ikey < ptr.info) { if (ptr . lthread == false) ptr = ptr . left; else break; } // Moving on right subtree. else { if (ptr.rthread == false) ptr = ptr . right; else break; } } // Create a new node Node tmp = new Node(); tmp . info = ikey; tmp . lthread = true; tmp . rthread = true; if (par == null) { root = tmp; tmp . left = null; tmp . right = null; } else if (ikey < (par . info)) { tmp . left = par . left; tmp . right = par; par . lthread = false; par . left = tmp; } else { tmp . left = par; tmp . right = par . right; par . rthread = false; par . right = tmp; } return root; } // Returns inorder successor using rthread static Node inorderSuccessor( Node ptr) { // If rthread is set we can quickly find if (ptr . rthread == true) return ptr.right; // Else return leftmost child of right subtree ptr = ptr . right; while (ptr . lthread == false) ptr = ptr . left; return ptr; } // Printing the threaded tree static void inorder( Node root) { if (root == null) System.out.printf('Tree is empty'); // Reach leftmost node Node ptr = root; while (ptr . lthread == false) ptr = ptr . left; // One by one print successors while (ptr != null) { System.out.printf('%d 'ptr . info); ptr = inorderSuccessor(ptr); } } // Driver Program public static void main(String[] args) { Node root = null; root = insert(root 20); root = insert(root 10); root = insert(root 30); root = insert(root 5); root = insert(root 16); root = insert(root 14); root = insert(root 17); root = insert(root 13); inorder(root); } } //contributed by Arnab Kundu // This code is updated By Susobhan Akhuli
# Insertion in Threaded Binary Search Tree. class newNode: def __init__(self key): # False if left pointer points to # predecessor in Inorder Traversal self.info = key self.left = None self.right =None self.lthread = True # False if right pointer points to # successor in Inorder Traversal self.rthread = True # Insert a Node in Binary Threaded Tree def insert(root ikey): # Searching for a Node with given value ptr = root par = None # Parent of key to be inserted while ptr != None: # If key already exists return if ikey == (ptr.info): print('Duplicate Key !') return root par = ptr # Update parent pointer # Moving on left subtree. if ikey < ptr.info: if ptr.lthread == False: ptr = ptr.left else: break # Moving on right subtree. else: if ptr.rthread == False: ptr = ptr.right else: break # Create a new node tmp = newNode(ikey) if par == None: root = tmp tmp.left = None tmp.right = None elif ikey < (par.info): tmp.left = par.left tmp.right = par par.lthread = False par.left = tmp else: tmp.left = par tmp.right = par.right par.rthread = False par.right = tmp return root # Returns inorder successor using rthread def inorderSuccessor(ptr): # If rthread is set we can quickly find if ptr.rthread == True: return ptr.right # Else return leftmost child of # right subtree ptr = ptr.right while ptr.lthread == False: ptr = ptr.left return ptr # Printing the threaded tree def inorder(root): if root == None: print('Tree is empty') # Reach leftmost node ptr = root while ptr.lthread == False: ptr = ptr.left # One by one print successors while ptr != None: print(ptr.infoend=' ') ptr = inorderSuccessor(ptr) # Driver Code if __name__ == '__main__': root = None root = insert(root 20) root = insert(root 10) root = insert(root 30) root = insert(root 5) root = insert(root 16) root = insert(root 14) root = insert(root 17) root = insert(root 13) inorder(root) # This code is contributed by PranchalK
using System; // C# program Insertion in Threaded Binary Search Tree. public class solution { public class Node { public Node left right; public int info; // False if left pointer points to predecessor // in Inorder Traversal public bool lthread; // False if right pointer points to successor // in Inorder Traversal public bool rthread; } // Insert a Node in Binary Threaded Tree public static Node insert(Node root int ikey) { // Searching for a Node with given value Node ptr = root; Node par = null; // Parent of key to be inserted while (ptr != null) { // If key already exists return if (ikey == (ptr.info)) { Console.Write('Duplicate Key !n'); return root; } par = ptr; // Update parent pointer // Moving on left subtree. if (ikey < ptr.info) { if (ptr.lthread == false) { ptr = ptr.left; } else { break; } } // Moving on right subtree. else { if (ptr.rthread == false) { ptr = ptr.right; } else { break; } } } // Create a new node Node tmp = new Node(); tmp.info = ikey; tmp.lthread = true; tmp.rthread = true; if (par == null) { root = tmp; tmp.left = null; tmp.right = null; } else if (ikey < (par.info)) { tmp.left = par.left; tmp.right = par; par.lthread = false; par.left = tmp; } else { tmp.left = par; tmp.right = par.right; par.rthread = false; par.right = tmp; } return root; } // Returns inorder successor using rthread public static Node inorderSuccessor(Node ptr) { // If rthread is set we can quickly find if (ptr.rthread == true) { return ptr.right; } // Else return leftmost child of right subtree ptr = ptr.right; while (ptr.lthread == false) { ptr = ptr.left; } return ptr; } // Printing the threaded tree public static void inorder(Node root) { if (root == null) { Console.Write('Tree is empty'); } // Reach leftmost node Node ptr = root; while (ptr.lthread == false) { ptr = ptr.left; } // One by one print successors while (ptr != null) { Console.Write('{0:D} 'ptr.info); ptr = inorderSuccessor(ptr); } } // Driver Program public static void Main(string[] args) { Node root = null; root = insert(root 20); root = insert(root 10); root = insert(root 30); root = insert(root 5); root = insert(root 16); root = insert(root 14); root = insert(root 17); root = insert(root 13); inorder(root); } } // This code is contributed by Shrikant13
<script> // javascript program Insertion in Threaded Binary Search Tree. class Node { constructor(){ this.left = null this.right = null; this.info = 0; // False if left pointer points to predecessor // in Inorder Traversal this.lthread = false; // False if right pointer points to successor // in Inorder Traversal this.rthread = false; } } // Insert a Node in Binary Threaded Tree function insert(root ikey) { // Searching for a Node with given value var ptr = root; var par = null; // Parent of key to be inserted while (ptr != null) { // If key already exists return if (ikey == (ptr.info)) { document.write('Duplicate Key !n'); return root; } par = ptr; // Update parent pointer // Moving on left subtree. if (ikey < ptr.info) { if (ptr.lthread == false) ptr = ptr.left; else break; } // Moving on right subtree. else { if (ptr.rthread == false) ptr = ptr.right; else break; } } // Create a new node var tmp = new Node(); tmp.info = ikey; tmp.lthread = true; tmp.rthread = true; if (par == null) { root = tmp; tmp.left = null; tmp.right = null; } else if (ikey < (par.info)) { tmp.left = par.left; tmp.right = par; par.lthread = false; par.left = tmp; } else { tmp.left = par; tmp.right = par.right; par.rthread = false; par.right = tmp; } return root; } // Returns inorder successor using rthread function inorderSuccessor(ptr) { // If rthread is set we can quickly find if (ptr.rthread == true) return ptr.right; // Else return leftmost child of right subtree ptr = ptr.right; while (ptr.lthread == false) ptr = ptr.left; return ptr; } // Printing the threaded tree function inorder(root) { if (root == null) document.write('Tree is empty'); // Reach leftmost node var ptr = root; while (ptr.lthread == false) ptr = ptr.left; // One by one print successors while (ptr != null) { document.write(ptr.info+' '); ptr = inorderSuccessor(ptr); } } // Driver Program var root = null; root = insert(root 20); root = insert(root 10); root = insert(root 30); root = insert(root 5); root = insert(root 16); root = insert(root 14); root = insert(root 17); root = insert(root 13); inorder(root); // This code contributed by aashish1995 </script>
Uitvoer
5 10 13 14 16 17 20 30
Tijdcomplexiteit: O(log N)
Ruimtecomplexiteit: O(1) omdat er geen extra ruimte wordt gebruikt.
Quiz maken