Ņemot vērā a BST , uzdevums ir dzēst mezglu šajā BST , ko var iedalīt 3 scenārijos:
1. gadījums. Izdzēsiet lapu mezglu BST
Dzēšana BST
2. gadījums. Izdzēsiet BST mezglu ar vienu bērnu
Viena pakārtota mezgla dzēšana arī ir vienkārša BST. Kopējiet bērnu uz mezglu un izdzēsiet mezglu .
Dzēšana BST
3. gadījums. Izdzēsiet mezglu ar abiem bērniem BST
Mezgla dzēšana ar abiem bērniem nav tik vienkārša. Šeit mums tas ir jādara mezgla dzēšana ir tāda, ka iegūtais koks atbilst BST īpašībām.
Viltība ir atrast mezgla nepareizo pēcteci. Kopējiet secības pēcteces saturu uz mezglu un izdzēsiet kārtas pēcteci.
Piezīme: Var izmantot arī Inorder priekšteci.
kausa šķirošana
Dzēšana binārajā kokā
Piezīme: Kārtības pēctecis ir vajadzīgs tikai tad, kad īstais bērns nav tukšs. Šajā konkrētajā gadījumā kārtas pēcteci var iegūt, atrodot minimālo vērtību mezgla labajā bērnā.
Ieteicamā prakse Dzēst mezglu no BST Izmēģiniet to!Dzēšanas darbības ieviešana BST:
C++ #include using namespace std; struct Node { int key; struct Node *left, *right; }; // A utility function to create a new BST node Node* newNode(int item) { Node* temp = new Node; temp->atslēga = prece; temp->pa kreisi = temp->pa labi = NULL; atgriešanās temperatūra; } // Lietderības funkcija, lai veiktu inorder šķērsošanu BST void inorder(Node* root) { if (root != NULL) { inorder(root->left); printf('%d ', root->key); inorder(sakne->pa labi); } } /* Lietderības funkcija, lai ievietotu jaunu mezglu ar doto atslēgu iekš * BST */ Node* insert(Node* node, int key) { /* Ja koks ir tukšs, atgrieziet jaunu mezglu */ if (node = = NULL) atgriež newNode(key); /* Pretējā gadījumā atkārtojiet lejup pa koku */ if (taustiņš< node->atslēga) mezgls->pa kreisi = ievietot(mezgls->pa kreisi, atslēga); else node->right = insert(mezgls->labais, atslēga); /* atgriež (nemainītu) mezgla rādītāju */ atgriež mezglu; } /* Ņemot vērā bināro meklēšanas koku un atslēgu, šī funkcija izdzēš atslēgu un atgriež jauno sakni */ Node* deleteNode(Node* root, int k) { // Bāzes reģistrs if (root == NULL) atgriež sakni; // Ja dzēšamā atslēga ir mazāka par saknes atslēgu, // tad tā atrodas kreisajā apakškokā if (k< root->taustiņš) { sakne->pa kreisi = deleteNode(root->left, k); atgriezt sakni; } // Ja dzēšamā atslēga ir lielāka par saknes atslēgu, // tad tā atrodas labajā apakškokā else if (k> root->key) { root->right = deleteNode(root->right , k); atgriezt sakni; } // Ja atslēga ir tāda pati kā root's atslēga, tad šis ir mezgls, kas jādzēš // Mezgls ar tikai vienu bērnu vai bez bērna if (root->left == NULL) { Node* temp = root-> pa labi; dzēst sakni; atgriešanās temperatūra; } else if (root->right == NULL) { Node* temp = root->left; dzēst sakni; atgriešanās temperatūra; } // Mezgls ar diviem bērniem: Iegūstiet kārtas pēcteci (mazākais // labajā apakškokā) Mezgls* succParent = sakne; Mezgls* succ = sakne->pa labi; while (succ->left != NULL) { succParent = succ; succ = succ->pa kreisi; } // Kopēt secības pēcteča saturu šajā mezglā root->key = succ->key; // Dzēst secības pēcteci if (succParent->left == succ) succParent->left = succ->right; else succParent->right = succ->right; dzēst succ; atgriezt sakni; } // Draivera kods int main() { /* Izveidosim šādu BST 50 / 30 70 / / 20 40 60 80 */ Node* root = NULL; sakne = ievietot(sakne, 50); sakne = ievietot(sakne, 30); sakne = ievietot(sakne, 20); sakne = ievietot(sakne, 40); sakne = ievietot(sakne, 70); sakne = ievietot(sakne, 60); sakne = ievietot(sakne, 80); printf('Oriģinālais BST: '); inorder(sakne); printf('
Dzēst lapas mezglu: 20
'); sakne = deleteNode(sakne, 20); printf('Modificēts BST koks pēc lapu mezgla dzēšanas:
'); inorder(sakne); printf('
Dzēst mezglu ar vienu bērnu: 70
'); sakne = deleteNode(sakne, 70); printf('Modificēts BST koks pēc viena bērnmezgla dzēšanas:
'); inorder(sakne); printf('
Dzēst mezglu ar abiem bērniem: 50
'); sakne = deleteNode(sakne, 50); printf('Modificēts BST koks pēc abu bērnu mezglu dzēšanas:
'); inorder(sakne); atgriezties 0; }> C #include #include struct Node { int key; struct Node *left, *right; }; // A utility function to create a new BST node struct Node* newNode(int item) { struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); temp->atslēga = prece; temp->pa kreisi = temp->pa labi = NULL; atgriešanās temperatūra; } // Lietderības funkcija, lai veiktu inorder šķērsošanu BST void inorder(struct Node* root) { if (root != NULL) { inorder(root->left); printf('%d ', root->key); inorder(sakne->pa labi); } } /* Lietderības funkcija jauna mezgla ievietošanai ar doto atslēgu BST */ struct Node* insert(struct Node* node, int key) { /* Ja koks ir tukšs, atgriež jaunu mezglu */ if (node == NULL) atgriež newNode(key); /* Pretējā gadījumā atkārtojiet lejup pa koku */ if (taustiņš< node->atslēga) mezgls->pa kreisi = ievietot(mezgls->pa kreisi, atslēga); else node->right = insert(mezgls->labais, atslēga); /* atgriež (nemainītu) mezgla rādītāju */ atgriež mezglu; } /* Izmantojot bināro meklēšanas koku un atslēgu, šī funkcija izdzēš atslēgu un atgriež jauno sakni */ struct Node* deleteNode(struct Node* root, int k) { // Pamata reģistrs if (root == NULL) return sakne; // Ja dzēšamā atslēga ir mazāka par saknes atslēgu, tad tā atrodas kreisajā apakškokā if (k< root->taustiņš) { sakne->pa kreisi = deleteNode(root->left, k); atgriezt sakni; } // Ja dzēšamā atslēga ir lielāka par saknes atslēgu, tad tā atrodas labajā apakškokā else if (k> root->key) { root->right = deleteNode(root->right, k ); atgriezt sakni; } // Ja atslēga ir tāda pati kā root's atslēga, tad šis ir mezgls, kas jādzēš // Mezgls ar tikai vienu bērnu vai bez bērna if (root->left == NULL) { struct Node* temp = root->pa labi; brīvs(sakne); atgriešanās temperatūra; } else if (root->right == NULL) { struct Node* temp = root->left; brīvs(sakne); atgriešanās temperatūra; } // Mezgls ar diviem bērniem: Iegūstiet kārtas pēcteci (mazāko labajā apakškokā) struct Node* succParent = sakne; struct Node* succ = root->right; while (succ->left != NULL) { succParent = succ; succ = succ->pa kreisi; } // Kopēt secības pēcteča saturu šajā mezglā root->key = succ->key; // Dzēst secības pēcteci if (succParent->left == succ) succParent->left = succ->right; else succParent->right = succ->right; bezmaksas(succ); atgriešanās sakne; } // Draivera kods int main() { /* Izveidosim šādu BST 50 / 30 70 / / 20 40 60 80 */ struct Node* root = NULL; sakne = ievietot(sakne, 50); ievietot(sakne, 30); ievietot(sakne, 20); ievietot(sakne, 40); ievietot(sakne, 70); ievietot(sakne, 60); ievietot(sakne, 80); printf('Oriģinālais BST: '); inorder(sakne); printf('
Dzēst lapas mezglu: 20
'); sakne = deleteNode(sakne, 20); printf('Modificēts BST koks pēc lapu mezgla dzēšanas:
'); inorder(sakne); printf('
Dzēst mezglu ar vienu bērnu: 70
'); sakne = deleteNode(sakne, 70); printf('Modificēts BST koks pēc viena bērnmezgla dzēšanas:
'); inorder(sakne); printf('
Dzēst mezglu ar abiem bērniem: 50
'); sakne = deleteNode(sakne, 50); printf('Modificēts BST koks pēc abu bērnu mezglu dzēšanas:
'); inorder(sakne); atgriezties 0; }> Java class Node { int key; Node left, right; Node(int item) { key = item; left = right = null; } } class BinaryTree { Node root; BinaryTree() { root = null; } // A utility function to insert a new node with the given key Node insert(Node node, int key) { // If the tree is empty, return a new node if (node == null) { return new Node(key); } // Otherwise, recur down the tree if (key < node.key) { node.left = insert(node.left, key); } else if (key>mezgls.atslēga) { mezgls.labais = ievietot(mezgls.labais, atslēga); } // atgriež (nemainītā) mezgla rādītāja atgriešanas mezglu; } // Lietderības funkcija BST inorder šķērsošanai void inorder(Node root) { if (root != null) { inorder(root.left); System.out.print(root.key + ' '); inorder(root.right); } } // Ņemot vērā bināro meklēšanas koku un atslēgu, šī funkcija izdzēš atslēgu un atgriež jauno sakni Node deleteNode(Node root, int key) { // Pamatlielums if (root == null) { return root; } // Ja dzēšamā atslēga ir mazāka par saknes atslēgu, tad tā atrodas kreisajā apakškokā if (taustiņa< root.key) { root.left = deleteNode(root.left, key); } // If the key to be deleted is greater than the root's key, then it lies in the right subtree else if (key>root.key) { root.right = deleteNode(root.right, key); } // Ja atslēga ir tāda pati kā root's atslēga, tad šis ir mezgls, kas jāizdzēš. else { // Mezgls ar tikai vienu bērnu vai bez bērna if (root.left == null) { return root.right; } else if (root.right == null) { return root.left; } // Mezgls ar diviem bērniem: iegūstiet kārtas pēcteci (mazāko labajā apakškokā) root.key = minValue(root.right); // Dzēst secības pēcteci root.right = deleteNode(root.right, root.key); } atgriezties sakne; } int minValue(Mezgla sakne) { int minv = root.key; while (root.left != null) { minv = root.left.key; sakne = root.left; } return minv; } // Draivera kods public static void main(String[] args) { BinaryTree tree = new BinaryTree(); /* Izveidosim šādu BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); koks.ievietot(koks.sakne, 30); koks.ievietot(koks.sakne, 20); koks.ievietot(koks.sakne, 40); koks.ievietot(koks.sakne, 70); koks.ievietot(koks.sakne, 60); koks.ievietot(koks.sakne, 80); System.out.print('Oriģinālais BST: '); koks.inorder(koks.sakne); System.out.println(); System.out.println('
Dzēst lapas mezglu: 20'); koks.sakne = koks.deleteNode(koks.sakne, 20); System.out.print('Modificēts BST koks pēc lapu mezgla dzēšanas:
'); koks.inorder(koks.sakne); System.out.println(); System.out.println('
Dzēst mezglu ar vienu bērnu: 70'); koks.sakne = koks.deleteNode(koks.sakne, 70); System.out.print('Modificēts BST koks pēc viena bērnmezgla dzēšanas:
'); koks.inorder(koks.sakne); System.out.println(); System.out.println('
Dzēst mezglu ar abiem bērniem: 50'); koks.sakne = koks.deleteNode(koks.sakne, 50); System.out.print('Modificēts BST koks pēc abu pakārtoto mezglu dzēšanas:
'); koks.inorder(koks.sakne); } }> Python3 class Node: def __init__(self, key): self.key = key self.left = None self.right = None class BinaryTree: def __init__(self): self.root = None # A utility function to insert a new node with the given key def insert(self, node, key): # If the tree is empty, return a new node if node is None: return Node(key) # Otherwise, recur down the tree if key < node.key: node.left = self.insert(node.left, key) elif key>node.key: node.right = self.insert(node.right, key) # atgriezt (nemainītu) mezgla rādītāju return node # Lietderības funkcija, lai veiktu BST inorder šķērsošanu def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Ņemot vērā bināro meklēšanas koku un atslēgu, šī funkcija izdzēš atslēgu un atgriež jauno saknes def deleteNode (self, root, key): # Pamatreģistrs, ja sakne ir None: atgriezt sakni # Ja dzēšamā atslēga ir mazāka par saknes atslēgu, tad tā atrodas kreisajā apakškokā if key< root.key: root.left = self.deleteNode(root.left, key) # If the key to be deleted is greater than the root's key, then it lies in the right subtree elif key>root.key: root.right = self.deleteNode(root.right, key) # Ja atslēga ir tāda pati kā saknes atslēga, tad šis ir mezgls, kas jādzēš citādi: # Mezgls ar tikai vienu bērnu vai bez bērna, ja root.left ir Nav: return root.right elif root.right ir Nav: return root.left # Mezgls ar diviem bērniem: iegūstiet kārtas pēcteci (labajā apakškokā mazāko) root.key = self.minValue(root.right) # Dzēst secības pēcteci root.right = self.deleteNode(root.right, root.key) return root def minValue(self, root): minv = root.key kamēr root.left: minv = root.left.key root = root.left return minv # Draivera kods if __name__ == '__main__': tree = BinaryTree() # Izveidosim šādu BST # 50 # / # 30 70 # / / # 20 40 60 80 tree.root = koks.ielikt(koks.sakne, 50) koks.ievietot(koks.sakne, 30) koks.ielikt(koks.sakne, 20) koks.ielikt(koks.sakne, 40) koks.ielikt(koks.sakne, 70) ) tree.insert(tree.root, 60) tree.insert(tree.root, 80) print('Original BST:', end=' ') tree.inorder(tree.root) print() print ('
Dzēst lapas mezglu: 20') tree.root = tree.deleteNode(tree.root, 20) print('Modificēts BST koks pēc lapas mezgla dzēšanas:') tree.inorder(tree.root) print() print('
Dzēst mezglu ar vienu bērnu: 70') tree.root = tree.deleteNode(tree.root, 70) print('Modificēts BST koks pēc viena bērna mezgla dzēšanas:') koks. inorder(tree.root) print() print('
Dzēst mezglu ar abiem bērniem: 50') tree.root = tree.deleteNode(tree.root, 50) print('Modificēts BST koks pēc abu pakārtoto mezglu dzēšanas :') koks.inorder(koks.sakne)> C# using System; public class Node { public int key; public Node left, right; public Node(int item) { key = item; left = right = null; } } public class BinaryTree { public Node root; // A utility function to insert a new node with the given key public Node Insert(Node node, int key) { // If the tree is empty, return a new node if (node == null) return new Node(key); // Otherwise, recur down the tree if (key < node.key) node.left = Insert(node.left, key); else if (key>node.key) node.right = Ievietot(mezgls.labais, atslēga); // atgriež (nemainītā) mezgla rādītāja atgriešanas mezglu; } // Lietderības funkcija, lai veiktu inorder šķērsošanu BST public void Inorder(Node root) { if (root != null) { Inorder(root.left); Console.Write(root.key + ' '); Kārtība(sakne.pa labi); } } // Ņemot vērā bināro meklēšanas koku un atslēgu, šī funkcija izdzēš atslēgu un atgriež jauno sakni publisko Node DeleteNode(Node root, int key) { // Pamatlielums if (root == null) return root; // Ja dzēšamā atslēga ir mazāka par saknes atslēgu, tad tā atrodas kreisajā apakškokā if (taustiņa< root.key) root.left = DeleteNode(root.left, key); // If the key to be deleted is greater than the root's key, then it lies in the right subtree else if (key>root.key) root.right = DeleteNode(root.right, key); // Ja atslēga ir tāda pati kā root's atslēga, tad šis ir mezgls, kas jādzēš else { // Mezgls ar tikai vienu bērnu vai bez bērna if (root.left == null) return root.right; else if (root.right == null) return root.left; // Mezgls ar diviem bērniem: iegūstiet kārtas pēcteci (mazāko labajā apakškokā) root.key = MinValue(root.right); // Dzēst secības pēcteci root.right = DeleteNode(root.right, root.key); } atgriezties sakne; } public int MinValue(Node root) { int minv = root.key; while (root.left != null) { minv = root.left.key; sakne = root.left; } return minv; } // Draivera kods public static void Main(string[] args) { BinaryTree tree = new BinaryTree(); /* Izveidosim šādu BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.Insert(tree.root, 50); koks.Ievietot(koks.sakne, 30); koks.Ievietot(koks.sakne, 20); koks.Ievietot(koks.sakne, 40); koks.Ievietot(koks.sakne, 70); koks.Ievietot(koks.sakne, 60); koks.Ievietot(koks.sakne, 80); Console.Write('Original BST: '); koks.Inorder(koks.sakne); Console.WriteLine(); Console.WriteLine('
Dzēst lapas mezglu: 20'); koks.sakne = koks.DzēstNode(koks.sakne, 20); Console.Write('Modificēts BST koks pēc lapu mezgla dzēšanas:
'); koks.Inorder(koks.sakne); Console.WriteLine(); Console.WriteLine('
Dzēst mezglu ar vienu bērnu: 70'); koks.sakne = koks.DzēstNode(koks.sakne, 70); Console.Write('Modificēts BST koks pēc viena bērnmezgla dzēšanas:
'); koks.Inorder(koks.sakne); Console.WriteLine(); Console.WriteLine('
Dzēst mezglu ar abiem bērniem: 50'); koks.sakne = koks.DzēstNode(koks.sakne, 50); Console.Write('Modificēts BST koks pēc abu pakārtoto mezglu dzēšanas:
'); koks.Inorder(koks.sakne); }> Javascript class Node { constructor(key) { this.key = key; this.left = null; this.right = null; } } class BinaryTree { constructor() { this.root = null; } // A utility function to insert a new node with the given key insert(node, key) { // If the tree is empty, return a new node if (node === null) return new Node(key); // Otherwise, recur down the tree if (key < node.key) node.left = this.insert(node.left, key); else if (key>mezgls.atslēga) node.right = this.insert(mezgls.labais, atslēga); // atgriež (nemainītā) mezgla rādītāja atgriešanas mezglu; } // Lietderības funkcija, lai veiktu BST inorder šķērsošanu inorder(node) { if (node !== null) { this.inorder(node.left); console.log(node.key + ' '); this.inorder(node.right); } } // Ņemot vērā bināro meklēšanas koku un atslēgu, šī funkcija izdzēš atslēgu un atgriež jauno sakni deleteNode(root, key) { // Pamatreģistrs if (root === null) return root; // Ja dzēšamā atslēga ir mazāka par saknes atslēgu, tad tā atrodas kreisajā apakškokā if (taustiņa< root.key) root.left = this.deleteNode(root.left, key); // If the key to be deleted is greater than the root's key, then it lies in the right subtree else if (key>root.key) root.right = this.deleteNode(root.right, key); // Ja atslēga ir tāda pati kā root's atslēga, tad šis ir mezgls, kas jāizdzēš else { // Mezgls ar tikai vienu bērnu vai bez bērna if (root.left === null) return root.right; else if (root.right === null) return root.left; // Mezgls ar diviem bērniem: iegūstiet kārtas pēcteci (mazāko labajā apakškokā) root.key = this.minValue(root.right); // Dzēst secības pēcteci root.right = this.deleteNode(root.right, root.key); } atgriezties sakne; } minValue(mezgls) { let minv = node.key; while (node.left !== null) { minv = node.left.key; mezgls = mezgls.pa kreisi; } return minv; } } // Draivera kods let tree = new BinaryTree(); /* Izveidosim šādu BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); koks.ievietot(koks.sakne, 30); koks.ievietot(koks.sakne, 20); koks.ievietot(koks.sakne, 40); koks.ievietot(koks.sakne, 70); koks.ievietot(koks.sakne, 60); koks.ievietot(koks.sakne, 80); console.log('Original BST:'); koks.inorder(koks.sakne); console.log('
Dzēst lapas mezglu: 20'); koks.sakne = koks.deleteNode(koks.sakne, 20); console.log('Modificēts BST koks pēc lapu mezgla dzēšanas:'); koks.inorder(koks.sakne); console.log('
Dzēst mezglu ar vienu bērnu: 70'); koks.sakne = koks.dzēstNode(koks.sakne, 70); console.log('Modificēts BST koks pēc viena bērnmezgla dzēšanas:'); koks.inorder(koks.sakne); console.log('
Dzēst mezglu ar abiem bērniem: 50'); koks.sakne = koks.deleteNode(koks.sakne, 50); console.log('Modificēts BST koks pēc abu bērnu mezglu dzēšanas:'); koks.inorder(koks.sakne);>>
Izvade Laika sarežģītība: O(h), kur h ir BST augstums.
Palīgtelpa: O(n). Saistītās saites: