Olemme jo keskustelleet Binäärisäikeinen binaaripuu .
Lisääminen binääripuuhun on samanlainen kuin lisäys binääripuuhun, mutta joudumme säätämään säikeitä jokaisen elementin lisäämisen jälkeen.
Binäärisäikeisen solmun C-esitys:
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; }; Seuraavassa selityksessä olemme pohtineet Binäärihakupuu (BST) lisäystä varten, koska lisäys määritellään joillakin BST:n säännöillä.
Anna tmp on juuri lisätty solmu . Lisäyksen aikana voi olla kolme tapausta:
Tapaus 1: Lisäys tyhjään puuhun
Sekä tmp:n vasen että oikea osoittimet asetetaan arvoon NULL ja uudesta solmusta tulee juuri.
Pyspark sql
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
Tapaus 2: Kun uusi solmu on lisätty vasemmaksi lapseksi
Kun solmu on lisätty oikeaan paikkaansa, meidän on tehtävä sen vasen ja oikea säike osoittavat järjestyksen edeltäjälle ja seuraajalle. Solmu, joka oli järjestyksen seuraaja . Joten uuden solmun vasen ja oikea säike on
java string.format
tmp -> left = par ->left; tmp -> right = par;
Ennen lisäystä vanhempien vasen osoitin oli säiettä, mutta lisäyksen jälkeen se on linkki, joka osoittaa uuteen solmuun.
par -> lthread = false; par -> left = temp;
Seuraava esimerkki näyttää solmun lisättävän vanhemman vasemman jälkeläisenä.
13 lisäämisen jälkeen
14:n edeltäjästä tulee luvun 13 edeltäjä, joten vasen lanka 13 pisteestä 10:een.
13:n seuraaja on 14, joten oikea lanka 13 pistettä vasempaan lapseen, joka on 13.
Vasen osoitin numerosta 14 ei ole lanka nyt se osoittaa vasempaan lasta, joka on 13.
kuvien keskittäminen css:ssä
Tapaus 3: Kun uusi solmu lisätään oikeana alatasona
Tmp:n emo on sen järjestyksen edeltäjä. Solmu, joka oli ylätason seuraaja, on nyt tämän solmun tmp seuraaja. Joten uuden solmun vasen ja oikea säike on
tmp -> left = par; tmp -> right = par -> right;
Ennen lisäystä oikea ylätason osoitin oli säiettä, mutta lisäyksen jälkeen se on linkki, joka osoittaa uuteen solmuun.
par -> rthread = false; par -> right = tmp;
Seuraava esimerkki osoittaa, että solmu on lisätty vanhemman oikeaksi lapseksi.
15 lisäyksen jälkeen
tojson java
14:n seuraajasta tulee 15:n seuraaja, joten oikea lanka 15 pistettä 16:een
15:n edeltäjä on 14, joten vasen lanka 15 pisteestä 14:ään.
Oikea osoitin numerosta 14 ei ole lanka nyt se osoittaa oikeaan lapseen, joka on 15.
C++-toteutus uuden solmun lisäämiseksi säikeistettyyn binaarihakupuuhun:
Pitää tavallinen BST-lisäosa etsimme avainarvoa puusta. Jos avain on jo olemassa, palaamme muuten uusi avain lisätään kohtaan, jossa haku päättyy. BST:ssä haku päättyy joko kun löydämme avaimen tai kun saavutamme NULL-vasemman tai oikean osoittimen. Tässä kaikki vasen ja oikea NULL-osoittimet korvataan säikeillä paitsi ensimmäisen solmun vasen osoitin ja viimeisen solmun oikea osoitin. Joten tässä haku epäonnistuu, kun saavutamme NULL-osoittimen tai säikeen.
java objektien tasa-arvo
Toteutus:
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>
Lähtö
5 10 13 14 16 17 20 30
Aika monimutkaisuus: O(log N)
Tilan monimutkaisuus: O(1) koska ylimääräistä tilaa ei ole käytetty.
Luo tietokilpailu