konuyu zaten tartışmıştık İkili Dişli İkili Ağaç .
İkili iş parçacıklı ağaca ekleme, ikili ağaca eklemeye benzer ancak her öğenin eklenmesinden sonra iş parçacıklarını ayarlamamız gerekecektir.
İkili Dişli Düğümün C gösterimi:
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; }; Aşağıdaki açıklamada ele aldığımız İkili Arama Ağacı (BST) ekleme olarak ekleme BST'lerdeki bazı kurallarla tanımlanır.
İzin vermek tmp yeni eklenen düğüm olsun . Ekleme sırasında üç durum olabilir:
Durum 1: Boş ağaca ekleme
Tmp'nin hem sol hem de sağ işaretçileri NULL olarak ayarlanacak ve yeni düğüm kök haline gelecektir.
ikili ağacın sipariş sonrası geçişi
root = tmp; tmp -> left = NULL; tmp -> right = NULL;
Durum 2: Sol alt öğe olarak yeni düğüm eklendiğinde
Düğümü uygun yerine yerleştirdikten sonra, onun sol ve sağ dişlerinin sırasıyla öncül ve ardılı işaret etmesini sağlamalıyız. Olan düğüm sıra dışı halef . Yani yeni düğümün sol ve sağ konuları-
Java dizesini değiştir
tmp -> left = par ->left; tmp -> right = par;
Eklemeden önce ebeveynin sol işaretçisi bir iş parçacığıydı ancak ekleme sonrasında yeni düğümü işaret eden bir bağlantı olacaktır.
par -> lthread = false; par -> left = temp;
Aşağıdaki örnek, ebeveyninin sol çocuğu olarak eklenen bir düğümü göstermektedir.
13'ün eklenmesinden sonra
14'ün selefi 13'ün selefi olur, böylece 13 puanlık konu 10'a bırakılır.
13'ün halefi 14'tür, yani sağdaki iplik 13 puandır ve soldaki çocuk 13'tür.
14'ün sol işaretçisi artık bir iş parçacığı değil, 13 olan sol çocuğa işaret ediyor.
Durum 3: Yeni düğüm sağ alt öğe olarak eklendiğinde
Tmp'nin ebeveyni onun sıralı öncülüdür. Ebeveynin sıralı halefi olan düğüm artık bu düğümün sıralı halefidir tmp. Yani yeni düğümün sol ve sağ konuları-
rdbms'deki birleştirme türleri
tmp -> left = par; tmp -> right = par -> right;
Eklemeden önce ebeveynin sağ işaretçisi bir iş parçacığıydı ancak eklemeden sonra yeni düğümü işaret eden bir bağlantı olacaktır.
par -> rthread = false; par -> right = tmp;
Aşağıdaki örnek, ebeveyninin sağ çocuğu olarak eklenen bir düğümü göstermektedir.
15 takıldıktan sonra
c programlamayı dahil et
14'ün ardılı 15'in ardılı olur, yani 15'in sağ dizisi 16'ya çıkar
15'in öncülü 14'tür, dolayısıyla 15 puanlık sol iş parçacığı 14'e düşer.
14'ün sağ işaretçisi artık bir konu değil, 15 olan sağ çocuğa işaret ediyor.
Dişli İkili Arama Ağacına yeni bir düğüm eklemek için C++ uygulaması:
Beğenmek standart BST kesici uç anahtar değerini ağaçta ararız. Anahtar zaten mevcutsa geri döneriz, aksi takdirde yeni anahtar aramanın sona erdiği noktaya eklenir. BST'de arama, anahtarı bulduğumuzda veya NULL sol veya sağ işaretçiye ulaştığımızda sona erer. Burada, ilk düğümün sol işaretçisi ve son düğümün sağ işaretçisi dışındaki tüm sol ve sağ NULL işaretçileri iş parçacıklarıyla değiştirilir. Yani burada bir NULL işaretçisine veya bir konuya ulaştığımızda arama başarısız olacaktır.
Uygulama:
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>
Çıkış
5 10 13 14 16 17 20 30
Zaman Karmaşıklığı: O(log N)
gizli uygulamalar nasıl alınır
Uzay Karmaşıklığı: O(1) fazladan alan kullanılmadığı için.
Test Oluştur