Mēs jau esam apsprieduši Binārais vītņots binārais koks .
Ievietošana binārajā kokā ir līdzīga ievietošanai binārajā kokā, taču mums būs jāpielāgo pavedieni pēc katra elementa ievietošanas.
Binārā vītņota mezgla C attēlojums:
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; }; Nākamajā skaidrojumā mēs esam apsvēruši Binārais meklēšanas koks (BST) ievietošanai, jo ievietošanu nosaka daži noteikumi BST.
Ļaujiet tmp ir tikko ievietotais mezgls . Ievietošanas laikā var būt trīs gadījumi:
1. gadījums: ievietošana tukšā kokā
Gan kreisais, gan labais tmp rādītājs tiks iestatīts uz NULL, un jaunais mezgls kļūst par sakni.
string.compareto c#
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
2. gadījums: kad jauns mezgls ir ievietots kā kreisais bērns
Pēc mezgla ievietošanas tā pareizajā vietā mums ir jānorāda, ka tā kreisais un labais pavediens norāda attiecīgi uz priekšgājēju un pēcteci. Mezgls, kas bija rīkojuma pēctecis . Tātad jaunā mezgla kreisais un labais pavediens būs-
nedeterminēti galīgi automāti
tmp -> left = par ->left; tmp -> right = par;
Pirms ievietošanas kreisais vecāka rādītājs bija pavediens, bet pēc ievietošanas tā būs saite, kas norāda uz jauno mezglu.
par -> lthread = false; par -> left = temp;
Nākamajā piemērā ir parādīts, ka mezgls tiek ievietots kā vecāka kreisais bērns.
Pēc 13. ievietošanas
14 priekštecis kļūst par 13 priekšteci, tātad kreisais pavediens no 13 punktiem pret 10.
13 pēctecis ir 14, tātad labais pavediens no 13 punktiem pret kreiso bērnu, kas ir 13.
Kreisais rādītājs 14 nav pavediens, tagad tas norāda uz kreiso bērnu, kas ir 13.
alfabēts pēc skaitļa
3. gadījums: kad jauns mezgls tiek ievietots kā pareizais bērns
Tmp vecākais ir tā priekšgājējs. Mezgls, kas bija vecākelementa kārtas pēctecis, tagad ir šī mezgla tmp kārtas pēctecis. Tātad jaunā mezgla kreisais un labais pavediens būs-
tmp -> left = par; tmp -> right = par -> right;
Pirms ievietošanas vecākais labais rādītājs bija pavediens, bet pēc ievietošanas tā būs saite, kas norāda uz jauno mezglu.
par -> rthread = false; par -> right = tmp;
Nākamajā piemērā ir parādīts, ka mezgls tiek ievietots kā tā vecāka pareizais bērns.
Pēc 15 ievietota
bash lasīšanas fails
14 pēctecis kļūst par 15 pēcteci, tātad pareizais pavediens no 15 punktiem līdz 16
15 priekštecis ir 14, tātad kreisais pavediens no 15 punktiem līdz 14.
Labais rādītājs 14 nav pavediens, tagad tas norāda uz labo bērnu, kuram ir 15.
C++ ieviešana, lai ievietotu jaunu mezglu Threaded Binary Search Tree:
Patīk standarta BST ieliktnis kokā meklējam galveno vērtību. Ja atslēga jau ir, mēs atgriežam, pretējā gadījumā jaunā atslēga tiek ievietota vietā, kur beidzas meklēšana. BST meklēšana beidzas, kad atrodam atslēgu, vai arī tad, kad sasniedzam NULL kreiso vai labo rādītāju. Šeit visas kreisās un labās NULL norādes tiek aizstātas ar pavedieniem, izņemot pirmā mezgla kreiso rādītāju un pēdējā mezgla labo rādītāju. Tātad šeit meklēšana būs neveiksmīga, kad sasniegsim NULL rādītāju vai pavedienu.
Android tālruņa iestatījumu izvēlne
Īstenošana:
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>
Izvade
5 10 13 14 16 17 20 30
Laika sarežģītība: O(log N)
Telpas sarežģītība: O(1) jo nav izmantota papildu vieta.
Izveidojiet viktorīnu