Nous avons déjà discuté du Arbre binaire fileté binaire .
L'insertion dans un arbre binaire à threads est similaire à l'insertion dans un arbre binaire mais nous devrons ajuster les threads après l'insertion de chaque élément.
Représentation C du nœud binaire threadé :
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; }; Dans l'explication suivante, nous avons considéré Arbre de recherche binaire (BST) pour l'insertion car l'insertion est définie par certaines règles dans les BST.
Laisser tmp est le nœud nouvellement inséré . Il peut y avoir trois cas lors de l'insertion :
Cas 1 : Insertion dans une arborescence vide
Les pointeurs gauche et droit de tmp seront définis sur NULL et le nouveau nœud deviendra la racine.
qu'est-ce que l'hibernation
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
Cas 2 : lorsqu'un nouveau nœud est inséré en tant qu'enfant de gauche
Après avoir inséré le nœud à sa place appropriée, nous devons faire en sorte que ses fils gauche et droit pointent respectivement vers le prédécesseur et le successeur. Le nœud qui était dans l'ordre successeur . Ainsi, les threads gauche et droit du nouveau nœud seront-
Kat Timpf soeur
tmp -> left = par ->left; tmp -> right = par;
Avant l'insertion, le pointeur gauche du parent était un fil de discussion mais après l'insertion, ce sera un lien pointant vers le nouveau nœud.
par -> lthread = false; par -> left = temp;
L'exemple suivant montre un nœud inséré en tant qu'enfant gauche de son parent.
Après insertion de 13
Le prédécesseur du 14 devient le prédécesseur du 13 donc il reste le fil de 13 points à 10.
Le successeur de 13 est 14 donc le fil droit de 13 pointe vers l'enfant gauche qui a 13.
Le pointeur gauche de 14 n'est pas un fil de discussion, il pointe maintenant vers l'enfant gauche qui a 13 ans.
Cas 3 : lorsqu'un nouveau nœud est inséré en tant que bon enfant
liste triée java
Le parent de tmp est son prédécesseur dans l'ordre. Le nœud qui était dans l'ordre le successeur du parent est désormais le successeur dans l'ordre de ce nœud tmp. Ainsi, les threads gauche et droit du nouveau nœud seront-
tmp -> left = par; tmp -> right = par -> right;
Avant l'insertion, le pointeur droit du parent était un fil de discussion mais après l'insertion, ce sera un lien pointant vers le nouveau nœud.
par -> rthread = false; par -> right = tmp;
L'exemple suivant montre un nœud inséré en tant qu'enfant droit de son parent.
garniture de chaîne Java
Après 15 inséré
Le successeur de 14 devient le successeur de 15 donc fil droit de 15 points à 16
Le prédécesseur de 15 est 14 donc le fil gauche de 15 pointe à 14.
Le pointeur droit de 14 n'est pas un fil de discussion, il pointe maintenant vers l'enfant droit qui a 15 ans.
Implémentation C++ pour insérer un nouveau nœud dans l'arbre de recherche binaire threadé :
Comme insert BST standard nous recherchons la valeur clé dans l’arbre. Si la clé est déjà présente alors nous revenons sinon la nouvelle clé est insérée au point où se termine la recherche. Dans BST, la recherche se termine soit lorsque nous trouvons la clé, soit lorsque nous atteignons un pointeur NULL gauche ou droit. Ici, tous les pointeurs NULL gauche et droit sont remplacés par des threads, à l'exception du pointeur gauche du premier nœud et du pointeur droit du dernier nœud. Donc ici, la recherche échouera lorsque nous atteindrons un pointeur NULL ou un fil de discussion.
Mise en œuvre:
concaténation SQLC++
// 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>
Sortir
5 10 13 14 16 17 20 30
Complexité temporelle : O (log N)
Complexité spatiale : O(1) puisqu'aucun espace supplémentaire n'est utilisé.
Créer un quiz