Având în vedere a BST , sarcina este să ștergeți un nod din acesta BST , care poate fi împărțit în 3 scenarii:
Cazul 1. Ștergeți un nod frunză în BST
Ștergere în BST
array.sort în java
Cazul 2. Ștergeți un nod cu un singur copil în BST
Ștergerea unui singur nod copil este, de asemenea, simplă în BST. Copiați copilul în nod și ștergeți nodul .
Ștergere în BST
Cazul 3. Ștergeți un nod cu ambii copii în BST
Ștergerea unui nod cu ambii copii nu este atât de simplă. Aici trebuie ștergeți nodul este astfel încât arborele rezultat să urmeze proprietățile unui BST.
ce este desktop.iniTrucul este să găsiți succesorul în ordine al nodului. Copiați conținutul succesorului în ordine în nod și ștergeți succesorul în ordine.
Notă: Predecesorul Inorder poate fi, de asemenea, utilizat.
numere blocate
Ștergerea în arbore binar
Notă: Succesorul în ordine este necesar doar atunci când copilul potrivit nu este gol. În acest caz particular, succesorul în ordine poate fi obținut prin găsirea valorii minime în copilul drept al nodului.
Practică recomandată Ștergeți un nod din BST Încercați!Implementarea operațiunii de ștergere într-un 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->cheie = element; temp->stânga = temp->dreapta = NULL; temperatura de retur; } // O funcție de utilitate pentru a face traversarea în ordine a BST void inorder(Node* rădăcină) { if (rădăcină != NULL) { inorder(rădăcină->stânga); printf('%d', root->key); în ordine(rădăcină->dreapta); } } /* O funcție utilitar pentru a insera un nou nod cu cheia dată în * BST */ Node* insert(Node* node, int key) { /* Dacă arborele este gol, returnează un nou nod */ if (nod = = NULL) return newNode(cheie); /* În caz contrar, repetați în jos în arbore */ if (key< node->cheie) nod->left = insert(nod->left, key); else nod->right = insert(nod->right, key); /* returnează pointerul nodului (neschimbat) */ returnează nodul; } /* Având în vedere un arbore de căutare binar și o cheie, această funcție șterge cheia și returnează noua rădăcină */ Node* deleteNode(Node* rădăcină, int k) { // Caz de bază dacă (rădăcină == NULL) returnează rădăcină; // Dacă cheia de șters este mai mică decât cheia rădăcinii, // atunci se află în subarborele din stânga dacă (k< root->cheie) { root->left = deleteNode(root->left, k); returnează rădăcină; } // Dacă cheia de șters este mai mare decât cheia rădăcinii, // atunci se află în subarborele din dreapta, altfel if (k> root->key) { root->right = deleteNode(root->right) , k); returnează rădăcină; } // Dacă cheia este aceeași cu cheia rădăcină, atunci acesta este nodul care trebuie șters // Nodul cu un singur copil sau fără copil dacă (rădăcină->stânga == NULL) { Nodul* temp = rădăcină-> dreapta; șterge rădăcină; temperatura de retur; } else if (rădăcină->dreapta == NULL) { Nodul* temp = rădăcină->stânga; șterge rădăcină; temperatura de retur; } // Nod cu doi copii: Obține succesorul în ordine (cel mai mic // în subarborele din dreapta) Node* succParent = root; Nod* succ = root->right; while (succ->left != NULL) { succParent = succ; succ = succ->left; } // Copiați conținutul succesorului în ordine în acest nod root->key = succ->key; // Șterge succesorul în ordine dacă (succParent->left == succ) succParent->left = succ->right; else succParent->right = succ->right; şterge succ; returnează rădăcină; } // Cod driver int main() { /* Să creăm următorul BST 50 / 30 70 / / 20 40 60 80 */ Node* root = NULL; rădăcină = insert(rădăcină, 50); rădăcină = insert(rădăcină, 30); rădăcină = insert (rădăcină, 20); rădăcină = insert (rădăcină, 40); rădăcină = insert (rădăcină, 70); rădăcină = insert (rădăcină, 60); rădăcină = insert (rădăcină, 80); printf('BST original: '); inorde (rădăcină); printf('
Ștergeți un nod frunză: 20
'); root = deleteNode(rădăcină, 20); printf('Arborele BST modificat după ștergerea Leaf Node:
'); inorde (rădăcină); printf('
Delete Node cu un singur copil: 70
'); root = deleteNode(rădăcină, 70); printf('Arborele BST modificat după ștergerea unui singur nod copil:
'); inorde (rădăcină); printf('
Delete Node cu ambele copii: 50
'); root = deleteNode(rădăcină, 50); printf('Arbore BST modificat după ștergerea ambelor nod copil:
'); inorde (rădăcină); întoarce 0; }>>>Ckey); în ordine(rădăcină->dreapta); } } /* O funcție utilitar pentru a insera un nou nod cu cheia dată în BST */ struct Node* insert(struct Node* node, int key) { /* Dacă arborele este gol, returnează un nou nod */ if (node == NULL) return newNode(cheie); /* În caz contrar, repetați în jos în arbore */ if (key< node->cheie) nod->left = insert(nod->left, key); else nod->right = insert(nod->right, key); /* returnează pointerul nodului (neschimbat) */ returnează nodul; } /* Având în vedere un arbore de căutare binar și o cheie, această funcție șterge cheia și returnează noua rădăcină */ struct Node* deleteNode(struct Node* root, int k) { // Caz de bază dacă (root == NULL) return rădăcină; // Dacă cheia de șters este mai mică decât cheia rădăcinii, atunci se află în subarborele din stânga dacă (k< root->cheie) { root->left = deleteNode(root->left, k); returnează rădăcină; } // Dacă cheia de șters este mai mare decât cheia rădăcinii, atunci se află în subarborele din dreapta altfel if (k> root->key) { root->right = deleteNode(root->right, k ); returnează rădăcină; } // Dacă cheia este aceeași cu cheia rădăcină, atunci acesta este nodul care trebuie șters // Nodul cu un singur copil sau fără copil dacă (rădăcină->stânga == NULL) { struct Node* temp = rădăcină-> dreapta; liber(rădăcină); temperatura de retur; } else if (rădăcină->dreapta == NULL) { struct Node* temp = rădăcină->stânga; liber(rădăcină); temperatura de retur; } // Nod cu doi copii: Obține succesorul în ordine (cel mai mic din subarborele din dreapta) struct Node* succParent = root; struct Node* succ = root->right; while (succ->left != NULL) { succParent = succ; succ = succ->left; } // Copiați conținutul succesorului în ordine în acest nod root->key = succ->key; // Șterge succesorul în ordine dacă (succParent->left == succ) succParent->left = succ->right; else succParent->right = succ->right; gratuit(succ); returnează rădăcină; } // Cod driver int main() { /* Să creăm următorul BST 50 / 30 70 / / 20 40 60 80 */ struct Node* root = NULL; rădăcină = insert (rădăcină, 50); insert (rădăcină, 30); insert (rădăcină, 20); insert (rădăcină, 40); insert (rădăcină, 70); insert (rădăcină, 60); insert (rădăcină, 80); printf('BST original: '); inorde (rădăcină); printf('
Ștergeți un nod frunză: 20
'); root = deleteNode(rădăcină, 20); printf('Arborele BST modificat după ștergerea Leaf Node:
'); inorde (rădăcină); printf('
Delete Node cu un singur copil: 70
'); root = deleteNode(rădăcină, 70); printf('Arborele BST modificat după ștergerea unui singur nod copil:
'); inorde (rădăcină); printf('
Delete Node cu ambele copii: 50
'); root = deleteNode(rădăcină, 50); printf('Arbore BST modificat după ștergerea ambelor nod copil:
'); inorde (rădăcină); întoarce 0; }>>> Javaroot.key) { root.right = deleteNode(root.right, key); } // Dacă cheia este aceeași cu cheia rădăcină, atunci acesta este nodul care trebuie șters else { // Nodul cu un singur copil sau fără copil if (root.left == null) { return root.right; } else if (root.right == null) { return root.left; } // Nod cu doi copii: Obțineți succesorul în ordine (cel mai mic din subarborele din dreapta) root.key = minValue(root.right); // Sterge succesorul in ordine root.right = deleteNode(root.right, root.key); } returnează rădăcină; } int minValue(Rădăcină nod) { int minv = root.key; while (root.left != null) { minv = root.left.key; root = root.left; } return minv; } // Cod driver public static void main(String[] args) { Arborele Binary = new BinaryTree(); /* Să creăm următorul BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); tree.insert(tree.root, 30); tree.insert(tree.root, 20); tree.insert(tree.root, 40); tree.insert(tree.root, 70); tree.insert(tree.root, 60); tree.insert(tree.root, 80); System.out.print('BST original: '); tree.inorder(tree.root); System.out.println(); System.out.println('
Delete a Leaf Node: 20'); tree.root = tree.deleteNode(tree.root, 20); System.out.print('Arborele BST modificat după ștergerea Leaf Node:
'); tree.inorder(tree.root); System.out.println(); System.out.println('
Delete Node with single child: 70'); tree.root = tree.deleteNode(tree.root, 70); System.out.print('Arborele BST modificat după ștergerea unui singur nod copil:
'); tree.inorder(tree.root); System.out.println(); System.out.println('
Delete Node cu ambele copii: 50'); tree.root = tree.deleteNode(tree.root, 50); System.out.print('Arborele BST modificat după ștergerea ambelor noduri fii:
'); tree.inorder(tree.root); } }>>> Python3root.key: root.right = self.deleteNode(root.right, key) # Dacă cheia este aceeași cu cheia root, atunci acesta este nodul care trebuie șters altfel: # Nod cu un singur copil sau niciun copil dacă root.left este None: return root.right elif root.right este None: return root.left # Nod cu doi copii: Obțineți succesorul în ordine (cel mai mic din subarborele din dreapta) root.key = self.minValue(root.right) # Ștergeți succesorul în ordine root.right = self.deleteNode(root.right, root.key) return root def minValue(self, root): minv = root.key while root.left: minv = root.left.key root = root.left return minv # Cod driver if __name__ == '__main__': tree = BinaryTree() # Să creăm următorul BST # 50 # / # 30 70 # / / # 20 40 60 80 tree.root = tree.insert(tree.root, 50) tree.insert(tree.root, 30) tree.insert(tree.root, 20) tree.insert(tree.root, 40) tree.insert(tree.root, 70) ) tree.insert(tree.root, 60) tree.insert(tree.root, 80) print('BST original:', end=' ') tree.inorder(tree.root) print() print ('
Ștergeți un nod frunză: 20') tree.root = tree.deleteNode(tree.root, 20) print('Arborele BST modificat după ștergerea nodului frunză:') tree.inorder(tree.root) print() print('
Delete Node cu un singur copil: 70') tree.root = tree.deleteNode(tree.root, 70) print('Arborele BST modificat după ștergerea unui singur copil Nod:'). inorder(tree.root) print() print('
Ștergeți nodul cu ambele copii: 50') tree.root = tree.deleteNode(tree.root, 50) print('Arborele BST modificat după ștergerea ambelor noduri copil :') tree.inorder(tree.root)> 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 = Insert(node.right, key); // returnează (neschimbat) pointerul nodului returnează nodul; } // O funcție de utilitate pentru a face traversarea în ordine a BST public void Inorder(Rădăcină nod) { if (rădăcină != null) { Inorder(rădăcină.stânga); Console.Write(root.key + ' '); În ordine(rădăcină.dreapta); } } // Având în vedere un arbore de căutare binar și o cheie, această funcție șterge cheia și returnează noua rădăcină publică Node DeleteNode(Rădăcină nod, cheie int) { // Caz de bază dacă (rădăcină == null) returnează rădăcină; // Dacă cheia de șters este mai mică decât cheia rădăcinii, atunci se află în subarborele din stânga dacă (cheia< 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); // Dacă cheia este aceeași cu cheia rădăcină, atunci acesta este nodul care trebuie șters else { // Nodul cu un singur copil sau fără copil dacă (root.left == null) returnează root.right; else if (root.right == null) returnează root.left; // Nod cu doi copii: Obțineți succesorul în ordine (cel mai mic din subarborele din dreapta) root.key = MinValue(root.right); // Sterge succesorul in ordine root.right = DeleteNode(root.right, root.key); } returnează rădăcină; } public int MinValue(Rădăcina nodului) { int minv = root.key; while (root.left != null) { minv = root.left.key; root = root.left; } return minv; } // Cod driver public static void Main(string[] args) { BinaryTree tree = new BinaryTree(); /* Să creăm următorul BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.Insert(tree.root, 50); tree.Insert(tree.root, 30); tree.Insert(tree.root, 20); tree.Insert(tree.root, 40); tree.Insert(tree.root, 70); tree.Insert(tree.root, 60); tree.Insert(tree.root, 80); Console.Write('BST original: '); tree.Inorder(tree.root); Console.WriteLine(); Console.WriteLine('
Delete a Leaf Node: 20'); tree.root = tree.DeleteNode(tree.root, 20); Console.Write('Arborele BST modificat după ștergerea Leaf Node:
'); tree.Inorder(tree.root); Console.WriteLine(); Console.WriteLine('
Delete Node with single child: 70'); tree.root = tree.DeleteNode(tree.root, 70); Console.Write('Arborele BST modificat după ștergerea unui singur nod copil:
'); tree.Inorder(tree.root); Console.WriteLine(); Console.WriteLine('
Delete Node cu ambele copii: 50'); tree.root = tree.DeleteNode(tree.root, 50); Console.Write('Arborele BST modificat după ștergerea ambelor nod copil:
'); tree.Inorder(tree.root); }>>>Javascriptroot.key) root.right = this.deleteNode(root.right, key); // Dacă cheia este aceeași cu cheia rădăcină, atunci acesta este nodul care trebuie șters else { // Nodul cu un singur copil sau fără copil dacă (root.left === null) returnează root.right; else if (root.right === null) returnează root.left; // Nod cu doi copii: Obține succesorul în ordine (cel mai mic din subarborele din dreapta) root.key = this.minValue(root.right); // Sterge succesorul in ordine root.right = this.deleteNode(root.right, root.key); } returnează rădăcină; } minValue(node) { let minv = node.key; while (node.left !== null) { minv = node.left.key; nod = nod.stânga; } return minv; } } // Cod driver let tree = nou BinaryTree(); /* Să creăm următorul BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); tree.insert(tree.root, 30); tree.insert(tree.root, 20); tree.insert(tree.root, 40); tree.insert(tree.root, 70); tree.insert(tree.root, 60); tree.insert(tree.root, 80); console.log('BST original:'); tree.inorder(tree.root); console.log('
Ștergeți un nod frunză: 20'); tree.root = tree.deleteNode(tree.root, 20); console.log('Arborele BST modificat după ștergerea Leaf Node:'); tree.inorder(tree.root); console.log('
Delete Node with single child: 70'); tree.root = tree.deleteNode(tree.root, 70); console.log('Arborele BST modificat după ștergerea unui singur nod copil:'); tree.inorder(tree.root); console.log('
Delete Node cu ambele copii: 50'); tree.root = tree.deleteNode(tree.root, 50); console.log('Arbore BST modificat după ștergerea ambelor noduri fii:'); tree.inorder(tree.root);>>>
Ieșire Complexitatea timpului: O(h), unde h este înălțimea BST.
Spațiu auxiliar: Pe). Linkuri conexe:
data locala