Atsižvelgiant į a BST , užduotis yra ištrinti mazgą BST , kurį galima suskirstyti į 3 scenarijus:
1 atvejis. Ištrinkite lapo mazgą BST
Ištrynimas BST
rasti mano iphone android
2 atvejis. Ištrinkite BST mazgą su vienu vaiku
BST taip pat paprasta ištrinti vieną antrinį mazgą. Nukopijuokite vaiką į mazgą ir ištrinkite mazgą .
Ištrynimas BST
3 atvejis. Ištrinkite BST mazgą su abiem vaikais
Ištrinti mazgą su abiem vaikais nėra taip paprasta. Čia mes turime Ištrinkite mazgą tokiu būdu, kad gautas medis atitiktų BST savybes.
Triukas yra rasti netvarkingą mazgo įpėdinį. Nukopijuokite eilės įpėdinio turinį į mazgą ir ištrinkite eilės įpėdinį.
Pastaba: Taip pat galima naudoti Inorder pirmtaką.
uml diagrama java
Ištrynimas dvejetainiame medyje
sesija pasibaigė
Pastaba: Tvarkos įpėdinis reikalingas tik tada, kai tinkamas vaikas nėra tuščias. Šiuo konkrečiu atveju eilės įpėdinį galima gauti suradus mažiausią reikšmę dešiniajame mazgo antryje.
Rekomenduojama praktika Ištrinkite mazgą iš BST Išbandykite!Ištrynimo operacijos įgyvendinimas 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->raktas = prekė; temp->left = temp->right = NULL; grąžinimo temperatūra; } // Naudingumo funkcija, skirta atlikti BST inorder perėjimą void inorder(Node* root) { if (root != NULL) { inorder(root->left); printf('%d ', root->key); inorder(root->right); } } /* Naudingumo funkcija įterpti naują mazgą su duotu raktu * BST */ Node* insert(Node* node, int key) { /* Jei medis tuščias, grąžinkite naują mazgą */ if (mazgas = = NULL) return newMazgas(raktas); /* Priešingu atveju pakartokite medį */ if (key< node->raktas) mazgas->kairė = įterpti(mazgas->kairysis, raktas); else mazgas->dešinė = įterpti(mazgas->dešinė, raktas); /* grąžinti (nepakeistą) mazgo rodyklę */ grąžinti mazgą; } /* Atsižvelgiant į dvejetainį paieškos medį ir raktą, ši funkcija ištrina raktą ir grąžina naują šaknį */ Mazgas* deleteNode(Node* root, int k) { // Pagrindinės raidės if (root == NULL) return root; // Jei norimas ištrinti raktas yra mažesnis nei šakninis raktas, // tada jis yra kairiajame pomedyje if (k< root->raktas) { root->left = deleteNode(root->left, k); grąžinti šaknį; } // Jei norimas ištrinti raktas yra didesnis nei šakninis raktas, // tada jis yra dešiniajame pomedyje else if (k> root->key) { root->right = deleteNode(root->right , k); grąžinti šaknį; } // Jei raktas yra toks pat kaip root's raktas, tada tai mazgas, kurį reikia ištrinti // Mazgas su tik vienu antruoju arba be vaiko if (root->left == NULL) { Mazgas* temp = root-> teisė; ištrinti šaknį; grąžinimo temperatūra; } else if (root->right == NULL) { Mazgas* temp = root->left; ištrinti šaknį; grąžinimo temperatūra; } // Mazgas su dviem vaikais: Gaukite eilės eilės įpėdinį (mažiausias // dešiniajame pomedyje) Mazgas* succParent = root; Mazgas* succ = root->right; while (succ->left != NULL) { succParent = succ; succ = succ->left; } // Nukopijuokite eilės įpėdinio turinį į šį mazgą root->key = succ->key; // Ištrinti eilės įpėdinį if (succParent->left == succ) succParent->left = succ->right; kitu atveju succParent->right = succ->right; ištrinti succ; grąžinti šaknį; } // Tvarkyklės kodas int main() { /* Sukurkime šiuos BST 50 / 30 70 / / 20 40 60 80 */ Mazgas* root = NULL; šaknis = įterpti(šaknis, 50); šaknis = įterpti(šaknis, 30); šaknis = įterpti(šaknis, 20); šaknis = įterpti(šaknis, 40); šaknis = įterpti(šaknis, 70); šaknis = įterpti(šaknis, 60); šaknis = įterpti(šaknis, 80); printf('Original BST: '); eilė(šaknis); printf('
Ištrinti lapo mazgą: 20
'); šaknis = deleteNode(šaknis, 20); printf('Pakeistas BST medis ištrynus lapų mazgą:
'); eilė(šaknis); printf('
Ištrinti mazgą su vienu vaiku: 70
'); šaknis = deleteNode(šaknis, 70); printf('Pakeistas BST medis ištrynus vieną antrinį mazgą:
'); eilė(šaknis); printf('
Ištrinti mazgą su abiem antriniais: 50
'); šaknis = deleteNode(šaknis, 50); printf('Pakeistas BST medis ištrynus abu antrinius mazgus:
'); eilė(šaknis); grąžinti 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->raktas = prekė; temp->left = temp->right = NULL; grąžinimo temperatūra; } // Naudingumo funkcija atlikti inorder perėjimą BST void inorder(struct Node* root) { if (root != NULL) { inorder(root->left); printf('%d ', root->key); inorder(root->right); } } /* Naudingumo funkcija įterpti naują mazgą su nurodytu raktu į BST */ struct Node* insert(struct Node* mazgas, int raktas) { /* Jei medis tuščias, grąžinkite naują mazgą */ if (mazgas == NULL) return newNode(key); /* Priešingu atveju pakartokite medį */ if (key< node->raktas) mazgas->kairė = įterpti(mazgas->kairysis, raktas); else mazgas->dešinė = įterpti(mazgas->dešinė, raktas); /* grąžinti (nepakeistą) mazgo rodyklę */ grąžinti mazgą; } /* Atsižvelgiant į dvejetainį paieškos medį ir raktą, ši funkcija ištrina raktą ir grąžina naują šaknį */ struct Node* deleteNode(struct Node* root, int k) { // Pagrindinės raidės if (root == NULL) return šaknis; // Jei norimas ištrinti raktas yra mažesnis nei šakninis raktas, jis yra kairiajame pomedyje if (k< root->raktas) { root->left = deleteNode(root->left, k); grąžinti šaknį; } // Jei norimas ištrinti raktas yra didesnis nei šakninis raktas, tada jis yra dešiniajame pomedyje else if (k> root->key) { root->right = deleteNode(root->right, k ); grąžinti šaknį; } // Jei raktas yra toks pat kaip root's raktas, tai mazgas, kurį reikia ištrinti // Mazgas su tik vienu antruoju arba be vaiko if (root->left == NULL) { struct Node* temp = root->dešinė; laisvas(šaknis); grąžinimo temperatūra; } else if (root->right == NULL) { struct Mazgas* temp = root->left; laisvas(šaknis); grąžinimo temperatūra; } // Mazgas su dviem vaikais: Gaukite eilės eilės įpėdinį (mažiausią dešiniajame pomedyje) struct Mazgas* succParent = šaknis; struct Mazgas* succ = root->right; while (succ->left != NULL) { succParent = succ; succ = succ->left; } // Nukopijuokite eilės įpėdinio turinį į šį mazgą root->key = succ->key; // Ištrinti eilės įpėdinį if (succParent->left == succ) succParent->left = succ->right; kitu atveju succParent->right = succ->right; nemokamas (succ); grąžinti šaknį; } // Tvarkyklės kodas int main() { /* Sukurkime šiuos BST 50 / 30 70 / / 20 40 60 80 */ struct Node* root = NULL; šaknis = įterpti(šaknis, 50); įterpti(šaknis, 30); įterpti(šaknis, 20); įterpti(šaknis, 40); įterpti(šaknis, 70); įterpti(šaknis, 60); įterpti(šaknis, 80); printf('Original BST: '); eilė(šaknis); printf('
Ištrinti lapo mazgą: 20
'); šaknis = deleteNode(šaknis, 20); printf('Pakeistas BST medis ištrynus lapų mazgą:
'); eilė(šaknis); printf('
Ištrinti mazgą su vienu vaiku: 70
'); šaknis = deleteNode(šaknis, 70); printf('Pakeistas BST medis ištrynus vieną antrinį mazgą:
'); eilė(šaknis); printf('
Ištrinti mazgą su abiem antriniais: 50
'); šaknis = deleteNode(šaknis, 50); printf('Pakeistas BST medis ištrynus abu antrinius mazgus:
'); eilė(šaknis); grąžinti 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>mazgas.raktas) { mazgas.dešinė = įterpti(mazgas.dešinė, raktas); } // grąžinti (nepakeistą) mazgo rodyklę return mazgas; } // Naudingumo funkcija, skirta atlikti BST inorder perėjimą void inorder(Node root) { if (root != null) { inorder(root.left); System.out.print(root.key + ' '); inorder(root.right); } } // Turint dvejetainį paieškos medį ir raktą, ši funkcija ištrina raktą ir grąžina naują šaknį Mazgas deleteNode(Node root, int key) { // Pagrindinės didžiosios ir mažosios raidės if (root == null) { return root; } // Jei norimas ištrinti raktas yra mažesnis už šakninį raktą, jis yra kairiajame pomedyje if (klavišas< 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); } // Jei raktas yra toks pat kaip root's raktas, tai yra mazgas, kurį reikia ištrinti else { // Mazgas su tik vienu antruoju arba be jo if (root.left == null) { return root.right; } else if (root.right == null) { return root.left; } // Mazgas su dviem vaikais: gauti eilės eilės įpėdinį (mažiausias dešiniajame pomedyje) root.key = minValue(root.right); // Ištrinkite eilės eilės įpėdinį root.right = deleteNode(root.right, root.key); } return root; } int minValue(Mazgo šaknis) { int minv = root.key; while (root.left != null) { minv = root.left.key; šaknis = root.left; } return minv; } // Tvarkyklės kodas public static void main(String[] args) { BinaryTree medis = new BinaryTree(); /* Sukurkime šiuos BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); medis.insert(medis.šaknis, 30); medis.įterpti(medis.šaknis, 20); medis.insert(medis.šaknis, 40); medis.insert(medis.šaknis, 70); medis.insert(medis.šaknis, 60); medis.insert(medis.šaknis, 80); System.out.print('Original BST: '); medis.inorder(medis.šaknis); System.out.println(); System.out.println('
Ištrinti lapo mazgą: 20'); medis.šaknis = medis.ištrintiMazgas(medis.šaknis, 20); System.out.print('Pakeistas BST medis ištrynus lapo mazgą:
'); medis.inorder(medis.šaknis); System.out.println(); System.out.println('
Ištrinti mazgą su vienu vaiku: 70'); medis.šaknis = medis.ištrintiMazgas(medis.šaknis, 70); System.out.print('Pakeistas BST medis ištrynus vieną antrinį mazgą:
'); medis.inorder(medis.šaknis); System.out.println(); System.out.println('
Ištrinti mazgą su abiem antriniais: 50'); medis.šaknis = medis.ištrintiMazgas(medis.šaknis, 50); System.out.print('Pakeistas BST medis ištrynus abu antrinius mazgus:
'); medis.inorder(medis.šaknis); } }>>Python3root.key: root.right = self.deleteNode(root.right, key) # Jei raktas yra toks pat kaip root raktas, tai yra mazgas, kuris turi būti ištrintas kitu atveju: # Mazgas su tik vienu antruoju arba be jo, jei root.left yra Nėra: return root.right elif root.right yra Nėra: return root.left # Mazgas su dviem vaikais: Gaukite eilės eilės įpėdinį (mažiausias dešiniajame pomedyje) root.key = self.minValue(root.right) # Ištrinkite eilės eilės įpėdinį root.right = self.deleteNode(root.right, root.key) return root def minValue(self, root): minv = root.key, o root.left: minv = root.left.key root = root.left return minv # Tvarkyklės kodas if __name__ == '__main__': tree = BinaryTree() # Sukurkime šiuos BST # 50 # / # 30 70 # / / # 20 40 60 80 tree.root = medis.įterpti(medis.šaknis, 50) medis.įterpti(medis.šaknis, 30) medis.įterpti(medis.šaknis, 20) medis.įterpti(medis.šaknis, 40) medis.insert(medis.šaknis, 70) ) tree.insert(tree.root, 60) tree.insert(tree.root, 80) print('Original BST:', end=' ') tree.inorder(tree.root) print() print ('
Ištrinti lapo mazgą: 20') tree.root = tree.deleteNode(tree.root, 20) print('Pakeistas BST medis ištrynus lapo mazgą:') tree.inorder(tree.root) print() print('
Ištrinti mazgą su vienu antruoju mazgu: 70') tree.root = tree.deleteNode(tree.root, 70) print('Pakeistas BST medis ištrynus vieną antrinį mazgą:') medis. inorder(tree.root) print() print('
Ištrinti mazgą su abiem antriniais mazgais: 50') tree.root = tree.deleteNode(tree.root, 50) print('Pakeistas BST medis ištrynus abu antrinius mazgus :') medis.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>mazgas.raktas) node.right = Įterpti(mazgas.dešinė, raktas); // grąžinti (nepakeistą) mazgą rodyklė return mazgas; } // Naudingumo funkcija, skirta atlikti BST inorder perėjimą public void Inorder(Node root) { if (root != null) { Inorder(root.left); Console.Write(root.key + ' '); Inorder(root.right); } } // Turint dvejetainį paieškos medį ir raktą, ši funkcija ištrina raktą ir grąžina naują šaknį viešas Mazgas DeleteNode(Mazgo šaknis, int raktas) { // Pagrindinės raidės if (root == null) return root; // Jei norimas ištrinti raktas yra mažesnis nei šakninis raktas, tada jis yra kairiajame pomedyje if (klavišas< 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); // Jei raktas yra toks pat kaip root's raktas, tai mazgas, kurį reikia ištrinti else { // Mazgas su tik vienu antruoju arba be vaiko if (root.left == null) return root.right; else if (root.right == null) return root.left; // Mazgas su dviem vaikais: gauti eilės eilės įpėdinį (mažiausias dešiniajame pomedyje) root.key = MinValue(root.right); // Ištrinti eilės įpėdinį root.right = DeleteNode(root.right, root.key); } return root; } public int MinValue(Mazgo šaknis) { int minv = root.key; while (root.left != null) { minv = root.left.key; šaknis = root.left; } return minv; } // Tvarkyklės kodas public static void Main(string[] args) { BinaryTree medis = new BinaryTree(); /* Sukurkime šiuos BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.Insert(tree.root, 50); medis.Įterpti(medis.šaknis, 30); medis.Įterpti(medis.šaknis, 20); medis.Įterpti(medis.šaknis, 40); medis.Įterpti(medis.šaknis, 70); medis.Įterpti(medis.šaknis, 60); medis.Įterpti(medis.šaknis, 80); Console.Write('Original BST: '); medis.Inorder(medis.šaknis); Console.WriteLine(); Console.WriteLine('
Ištrinti lapo mazgą: 20'); medis.šaknis = medis.IštrintiMazgas(medis.šaknis, 20); Console.Write('Pakeistas BST medis ištrynus lapų mazgą:
'); medis.Inorder(medis.šaknis); Console.WriteLine(); Console.WriteLine('
Ištrinti mazgą su vienu vaiku: 70'); medis.šaknis = medis.DeleteNode(tree.root, 70); Console.Write('Pakeistas BST medis ištrynus vieną antrinį mazgą:
'); medis.Inorder(medis.šaknis); Console.WriteLine(); Console.WriteLine('
Ištrinti mazgą su abiem antriniais: 50'); medis.šaknis = medis.DeleteNode(tree.root, 50); Console.Write('Pakeistas BST medis ištrynus abu antrinius mazgus:
'); medis.Inorder(medis.šaknis); }> 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>mazgas.raktas) mazgas.dešinė = this.insert(mazgas.dešinė, raktas); // grąžinti (nepakeistą) mazgą rodyklė return mazgas; } // Naudingumo funkcija, skirta atlikti inorder perėjimą BST inorder(node) { if (mazgas !== null) { this.inorder(node.left); console.log(mazgas.key + ' '); this.inorder(mazgas.dešinė); } } // Turint dvejetainį paieškos medį ir raktą, ši funkcija ištrina raktą ir grąžina naują šaknį deleteNode(root, key) { // Pagrindinės didžiosios ir mažosios raidės if (root === null) return root; // Jei norimas ištrinti raktas yra mažesnis nei šakninis raktas, tada jis yra kairiajame pomedyje if (klavišas< 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); // Jei raktas yra toks pat kaip root's raktas, tai mazgas, kurį reikia ištrinti else { // Mazgas su tik vienu antruoju arba be vaiko if (root.left === null) return root.right; else if (root.right === null) return root.left; // Mazgas su dviem vaikais: gauti eilės įpėdinį (mažiausias dešiniajame pomedyje) root.key = this.minValue(root.right); // Ištrinkite eilės eilės įpėdinį root.right = this.deleteNode(root.right, root.key); } return root; } minValue(mazgas) { tegul minv = mazgas.raktas; while (mazgas.kairysis !== null) { minv = mazgas.kairysis.raktas; mazgas = mazgas.kairėje; } return minv; } } // Tvarkyklės kodas let tree = new BinaryTree(); /* Sukurkime šiuos BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); medis.insert(medis.šaknis, 30); medis.insert(medis.šaknis, 20); medis.insert(medis.šaknis, 40); medis.įterpti(medis.šaknis, 70); medis.įterpti(medis.šaknis, 60); medis.insert(medis.šaknis, 80); console.log('Original BST:'); medis.inorder(medis.šaknis); console.log('
Ištrinti lapo mazgą: 20'); medis.šaknis = medis.ištrintiMazgas(medis.šaknis, 20); console.log('Pakeistas BST medis ištrynus lapų mazgą:'); medis.inorder(medis.šaknis); console.log('
Ištrinti mazgą su vienu vaiku: 70'); medis.šaknis = medis.ištrintiMazgas(medis.šaknis, 70); console.log('Pakeistas BST medis ištrynus vieną antrinį mazgą:'); medis.inorder(medis.šaknis); console.log('
Ištrinti mazgą su abiem antriniais: 50'); medis.šaknis = medis.ištrintiMazgas(medis.šaknis, 50); console.log('Pakeistas BST medis ištrynus abu antrinius mazgus:'); medis.inorder(medis.šaknis);>>
Išvestis Laiko sudėtingumas: O(h), kur h yra BST aukštis.
Pagalbinė erdvė: O(n). Susijusios nuorodos: