Smo že razpravljali o Binarno navojno binarno drevo .
Vstavljanje v binarno navojno drevo je podobno vstavljanju v binarno drevo, vendar bomo morali prilagoditi niti po vstavitvi vsakega elementa.
C predstavitev binarnega navojnega vozlišča:
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; }; V naslednji razlagi smo upoštevali Binarno iskalno drevo (BST) za vstavljanje, saj je vstavljanje določeno z nekaterimi pravili v BST.
Naj tmp bo na novo vstavljeno vozlišče . Med vstavljanjem lahko pride do treh primerov:
Primer 1: Vstavljanje v prazno drevo
Levi in desni kazalec tmp bosta nastavljena na NULL in novo vozlišče postane korensko.
onclick js
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
Primer 2: Ko je novo vozlišče vstavljeno kot levi podrejeni element
Ko vozlišče vstavimo na njegovo pravo mesto, moramo njegov levi in desni navoj usmeriti na predhodnika in naslednika po vrstnem redu. Vozlišče, ki je bilo inorder naslednik . Torej bosta leva in desna nit novega vozlišča-
c logično
tmp -> left = par ->left; tmp -> right = par;
Pred vstavitvijo je bil levi kazalec nadrejenega elementa nit, po vstavitvi pa bo povezava, ki kaže na novo vozlišče.
par -> lthread = false; par -> left = temp;
Naslednji primer prikazuje vozlišče, ki je vstavljeno kot levi podrejeni element svojega nadrejenega.
Po vstavitvi 13
Predhodnik 14 postane predhodnik 13, zato leva nit 13 kaže na 10.
Naslednik 13 je 14, zato desna nit 13 kaže na levega otroka, ki je 13.
Levi kazalec od 14 ni nit, zdaj kaže na levega otroka, ki je 13.
ddl proti dml
Primer 3: Ko je novo vozlišče vstavljeno kot pravi podrejeni element
Nadrejeni element tmp je njegov predhodnik po vrstnem redu. Vozlišče, ki je bilo po vrstnem redu naslednik nadrejenega, je zdaj po vrstnem redu naslednik tega vozlišča tmp. Torej bosta leva in desna nit novega vozlišča-
tmp -> left = par; tmp -> right = par -> right;
Pred vstavitvijo je bil desni kazalec nadrejenega nit, po vstavitvi pa bo povezava, ki kaže na novo vozlišče.
par -> rthread = false; par -> right = tmp;
Naslednji primer prikazuje vozlišče, ki je vstavljeno kot desni podrejeni element svojega nadrejenega.
Po 15 vstavljenih
javascript za zanko
Naslednik 14 postane naslednik 15, zato desna nit 15 kaže na 16
Predhodnik 15 je 14, zato leva nit 15 kaže na 14.
Desni kazalec od 14 ni nit, zdaj kaže na desnega otroka, ki je 15.
Implementacija C++ za vstavljanje novega vozlišča v drevo binarnega iskanja z nitkami:
Všeč mi je standardni BST vložek iščemo vrednost ključa v drevesu. Če je ključ že prisoten, vrnemo, sicer se nov ključ vstavi na točki, kjer se iskanje konča. V BST se iskanje konča, ko najdemo ključ ali ko dosežemo NULL levi ali desni kazalec. Tukaj so vsi levi in desni kazalci NULL nadomeščeni z nitmi, razen levega kazalca prvega vozlišča in desnega kazalca zadnjega vozlišča. Iskanje bo torej neuspešno, ko dosežemo kazalec NULL ali nit.
oblikovati datum v niz
Izvedba:
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>
Izhod
5 10 13 14 16 17 20 30
Časovna kompleksnost: O(log N)
Prostorska kompleksnost: O(1) ker ni uporabljenega dodatnega prostora.
Ustvari kviz