Wir haben das bereits besprochen Binärer Thread-Binärbaum .
Das Einfügen in einen binären Thread-Baum ähnelt dem Einfügen in einen binären Baum, wir müssen jedoch die Threads nach dem Einfügen jedes Elements anpassen.
C-Darstellung des Binary Threaded Node:
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 der folgenden Erklärung haben wir darüber nachgedacht Binärer Suchbaum (BST) für die Einfügung, da die Einfügung durch einige Regeln in BSTs definiert ist.
Lassen tmp ist der neu eingefügte Knoten . Beim Einfügen kann es drei Fälle geben:
Fall 1: Einfügen in einen leeren Baum
Sowohl der linke als auch der rechte Zeiger von tmp werden auf NULL gesetzt und der neue Knoten wird zum Stamm.
Applet
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
Fall 2: Wenn ein neuer Knoten als linkes Kind eingefügt wird
Nachdem wir den Knoten an der richtigen Stelle eingefügt haben, müssen wir dafür sorgen, dass seine linken und rechten Threads auf den Vorgänger bzw. Nachfolger in der Reihenfolge zeigen. Der Knoten, der war ungeordneter Nachfolger . Der linke und der rechte Thread des neuen Knotens werden also-
Java for-Schleife
tmp -> left = par ->left; tmp -> right = par;
Vor dem Einfügen war der linke Zeiger des übergeordneten Knotens ein Thread, nach dem Einfügen ist er jedoch ein Link, der auf den neuen Knoten zeigt.
par -> lthread = false; par -> left = temp;
Das folgende Beispiel zeigt, wie ein Knoten als linkes untergeordnetes Element seines übergeordneten Knotens eingefügt wird.
Nach dem Einfügen von 13
Logik erster Ordnung
Der Vorgänger von 14 wird zum Vorgänger von 13, also linker Thread von 13 zu 10.
Der Nachfolger von 13 ist 14, also zeigt der rechte Thread von 13 auf das linke Kind, das 13 ist.
Der linke Zeiger von 14 ist kein Thread, sondern zeigt jetzt auf das linke untergeordnete Element, das 13 ist.
Fall 3: Wenn ein neuer Knoten als rechtes Kind eingefügt wird
Das übergeordnete Element von tmp ist sein inorder-Vorgänger. Der Knoten, der der Nachfolger des übergeordneten Knotens war, ist nun der Nachfolger dieses Knotens tmp. Der linke und der rechte Thread des neuen Knotens werden also-
tmp -> left = par; tmp -> right = par -> right;
Vor dem Einfügen war der rechte Zeiger des übergeordneten Knotens ein Thread, nach dem Einfügen ist er jedoch ein Link, der auf den neuen Knoten zeigt.
par -> rthread = false; par -> right = tmp;
Das folgende Beispiel zeigt, wie ein Knoten als rechtes untergeordnetes Element seines übergeordneten Knotens eingefügt wird.
Java-String zum Zeichen
Nach 15 eingefügt
Der Nachfolger von 14 wird zum Nachfolger von 15, also rechter Thread von 15 zu 16
Vorgänger von 15 ist 14, also linker Thread von 15 Punkte auf 14.
Der rechte Zeiger von 14 ist kein Thread, sondern zeigt auf das rechte untergeordnete Element, das 15 ist.
C++-Implementierung zum Einfügen eines neuen Knotens in den Threaded Binary Search Tree:
Wie Standard-BST-Einsatz Wir suchen nach dem Schlüsselwert im Baum. Wenn der Schlüssel bereits vorhanden ist, kehren wir zurück, andernfalls wird der neue Schlüssel an der Stelle eingefügt, an der die Suche endet. Bei BST endet die Suche entweder, wenn wir den Schlüssel finden oder wenn wir einen NULL-Links- oder Rechtszeiger erreichen. Hier werden alle linken und rechten NULL-Zeiger durch Threads ersetzt, mit Ausnahme des linken Zeigers des ersten Knotens und des rechten Zeigers des letzten Knotens. Hier ist die Suche also erfolglos, wenn wir einen NULL-Zeiger oder einen Thread erreichen.
Durchführung:
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>
Ausgabe
5 10 13 14 16 17 20 30
Zeitkomplexität: O(log N)
Raumkomplexität: O(1) da kein zusätzlicher Platz genutzt wird.
Rujira Banerjee
Quiz erstellen