Givet a BST , uppgiften är att ta bort en nod i denna BST , som kan delas upp i tre scenarier:
Fall 1. Ta bort en lövnod i BST
Radering i BST
hur man får apple emojis på Android
Fall 2. Ta bort en nod med enskilt barn i BST
Att ta bort en enda barnnod är också enkelt i BST. Kopiera barnet till noden och ta bort noden .
Radering i BST
Fall 3. Ta bort en nod med båda barnen i BST
Att ta bort en nod med båda barnen är inte så enkelt. Här måste vi ta bort noden är ett sådant sätt att det resulterande trädet följer egenskaperna för en BST.
Tricket är att hitta nodens efterföljare i ordningsföljd. Kopiera innehållet i inorderns efterföljare till noden och ta bort inorder efterföljaren.
Notera: Inorder föregångare kan också användas.
romersk siffra 1 till 100
Borttagning i binärt träd
knn algoritm
Notera: Inorder efterträdare behövs endast när rätt barn inte är tomt. I det här speciella fallet kan efterföljaren erhållas genom att hitta minimivärdet i nodens högra underordnade.
Rekommenderad praxis Ta bort en nod från BST Prova det!Implementering av raderingsoperation i en 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->nyckel = objekt; temp->vänster = temp->höger = NULL; returtemp; } // En verktygsfunktion för att göra inorderpassering av BST void inorder(Node* rot) { if (root != NULL) { inorder(root->left); printf('%d ', root->nyckel); inorder(root->höger); } } /* En verktygsfunktion för att infoga en ny nod med given nyckel i * BST */ Node* insert(Node* nod, int-nyckel) { /* Om trädet är tomt, returnera en ny nod */ if (nod = = NULL) returnera newNode(nyckel); /* I annat fall återkommer du i trädet */ if (nyckel< node->nyckel) nod->vänster = infoga(nod->vänster, nyckel); else node->höger = infoga(nod->höger, nyckel); /* returnera (oförändrad) nodpekare */ returnod; } /* Givet ett binärt sökträd och en nyckel, tar denna funktion bort nyckeln och returnerar den nya roten */ Node* deleteNode(Node* rot, int k) { // Base case if (root == NULL) return root; // Om nyckeln som ska raderas är mindre än rotens nyckel, // så ligger den i det vänstra underträdet om (k< root->key) { root->left = deleteNode(root->left, k); returnera rot; } // Om nyckeln som ska raderas är större än rotens nyckel, // så ligger den i det högra underträdet annars om (k> root->key) { root->right = deleteNode(root->right k); returnera rot; } // Om nyckeln är samma som rotnyckeln är detta noden som ska raderas // Nod med endast ett barn eller inget barn om (root->vänster == NULL) { Node* temp = root-> höger; ta bort root; returtemp; } else if (root->right == NULL) { Node* temp = root->left; ta bort root; returtemp; } // Nod med två barn: Hämta efterföljaren i ordningsföljden (minst // i det högra underträdet) Nod* succParent = rot; Nod* succ = rot->höger; while (succ->vänster != NULL) { succParent = succ; succ = succ->vänster; } // Kopiera efterföljarens innehåll till denna nod root->key = succ->key; // Ta bort efterföljaren i ordningen om (succParent->vänster == succ) succParent->left = succ->höger; else succParent->right = succ->right; ta bort succ; returnera rot; } // Driver Code int main() { /* Låt oss skapa följande BST 50 / 30 70 / / 20 40 60 80 */ Nod* root = NULL; root = insert(root, 50); root = insert(root, 30); root = insert(root, 20); root = insert(root, 40); root = insert(root, 70); root = insert(root, 60); root = insert(root, 80); printf('Original BST: '); inorder(root); printf('
Ta bort en bladnod: 20
'); root = deleteNode(root, 20); printf('Ändrad BST-träd efter borttagning av Leaf Node:
'); inorder(root); printf('
Ta bort nod med enskilt barn: 70
'); root = deleteNode(root, 70); printf('Ändrad BST-träd efter borttagning av enskild nod:
'); inorder(root); printf('
Ta bort nod med båda underordnade: 50
'); root = deleteNode(root, 50); printf('Ändrad BST-träd efter att ha tagit bort båda underordnade Node:
'); inorder(root); returnera 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->nyckel = objekt; temp->vänster = temp->höger = NULL; returtemp; } // En verktygsfunktion för att göra inorderpassering av BST void inorder(struct Node* root) { if (root != NULL) { inorder(root->left); printf('%d ', root->nyckel); inorder(root->höger); } } /* En verktygsfunktion för att infoga en ny nod med given nyckel i BST */ struct Node* insert(struct Node* node, int-nyckel) { /* Om trädet är tomt, returnera en ny nod */ if (nod) == NULL) returnera newNode(nyckel); /* I annat fall återkommer du i trädet */ if (nyckel< node->nyckel) nod->vänster = infoga(nod->vänster, nyckel); else node->höger = infoga(nod->höger, nyckel); /* returnera (oförändrad) nodpekare */ returnod; } /* Givet ett binärt sökträd och en nyckel tar denna funktion bort nyckeln och returnerar den nya roten */ struct Node* deleteNode(struct Node* rot, int k) { // Base case if (root == NULL) return rot; // Om nyckeln som ska raderas är mindre än rotens nyckel, så ligger den i det vänstra underträdet om (k< root->key) { root->left = deleteNode(root->left, k); returnera rot; } // Om nyckeln som ska raderas är större än rotens nyckel, så ligger den i det högra underträdet annars om (k> root->key) { root->right = deleteNode(root->right, k ); returnera rot; } // Om nyckeln är samma som rotnyckeln, så är detta noden som ska raderas // Nod med endast ett barn eller inget underordnat om (root->vänster == NULL) { struct Node* temp = root->rätt; fri (rot); returtemp; } else if (root->right == NULL) { struct Node* temp = root->left; fri (rot); returtemp; } // Nod med två barn: Hämta efterföljaren i ordningsföljden (minst i det högra underträdet) struct Node* succParent = rot; struct Node* succ = root->right; while (succ->vänster != NULL) { succParent = succ; succ = succ->vänster; } // Kopiera efterföljarens innehåll till denna nod root->key = succ->key; // Ta bort efterföljaren i ordningen om (succParent->vänster == succ) succParent->left = succ->höger; else succParent->right = succ->right; fri(succ); returnera rot; } // Driver Code int main() { /* Låt oss skapa följande BST 50 / 30 70 / / 20 40 60 80 */ struct Node* root = NULL; root = insert(root, 50); insert(root, 30); insert(root, 20); insert(root, 40); insert(root, 70); insert(root, 60); insert(root, 80); printf('Original BST: '); inorder(root); printf('
Ta bort en bladnod: 20
'); root = deleteNode(root, 20); printf('Ändrad BST-träd efter borttagning av Leaf Node:
'); inorder(root); printf('
Ta bort nod med enskilt barn: 70
'); root = deleteNode(root, 70); printf('Ändrad BST-träd efter borttagning av enskild nod:
'); inorder(root); printf('
Ta bort nod med båda underordnade: 50
'); root = deleteNode(root, 50); printf('Ändrad BST-träd efter att ha tagit bort båda underordnade Node:
'); inorder(root); returnera 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>node.key) { node.right = infoga(nod.höger, nyckel); } // returnera den (oförändrade) nodpekarens returnod; } // En verktygsfunktion för att göra inorderpassering av BST void inorder(Nodrot) { if (root != null) { inorder(root.left); System.out.print(root.key + ' '); inorder(root.right); } } // Givet ett binärt sökträd och en nyckel, tar denna funktion bort nyckeln och returnerar den nya rotnoden deleteNode(Nodrot, int nyckel) { // Basfall if (root == null) { return root; } // Om nyckeln som ska raderas är mindre än rotens nyckel, så ligger den i det vänstra underträdet om (nyckel< 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, nyckel); } // Om nyckeln är samma som rotnyckeln, så är detta noden som ska raderas annars { // Nod med endast ett barn eller inget underordnat if (root.left == null) { return root.right; } else if (root.right == null) { return root.left; } // Nod med två barn: Hämta efterföljaren i ordningsföljden (minst i det högra underträdet) root.key = minValue(root.right); // Ta bort ordningens efterföljare root.right = deleteNode(root.right, root.key); } returnera rot; } int minValue(Nodrot) { int minv = rot.nyckel; while (root.left != null) { minv = root.left.key; root = root.vänster; } returnera minv; } // Driver Code public static void main(String[] args) { BinaryTree tree = new BinaryTree(); /* Låt oss skapa följande 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('Original BST: '); tree.inorder(träd.rot); System.out.println(); System.out.println('
Ta bort en bladnod: 20'); tree.root = tree.deleteNode(tree.root, 20); System.out.print('Ändrad BST-träd efter borttagning av Leaf Node:
'); tree.inorder(träd.rot); System.out.println(); System.out.println('
Ta bort nod med enskilt barn: 70'); tree.root = tree.deleteNode(tree.root, 70); System.out.print('Ändrad BST-träd efter radering av enskild nod:
'); tree.inorder(träd.rot); System.out.println(); System.out.println('
Ta bort nod med båda underordnade: 50'); tree.root = tree.deleteNode(tree.root, 50); System.out.print('Ändrad BST-träd efter borttagning av båda underordnade Nod:
'); tree.inorder(träd.rot); } }> 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, nyckel) # returnera den (oförändrade) nodpekaren returnod # En verktygsfunktion för att göra inorderövergång av BST def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Givet ett binärt sökträd och en nyckel, tar denna funktion bort nyckeln och returnerar den nya root def deleteNode (själv, rot, nyckel): # Basfall om root är Ingen: returnera rot # Om nyckeln som ska raderas är mindre än rotens nyckel, så ligger den i det vänstra underträdet om nyckeln< 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, nyckel) # Om nyckeln är samma som root-nyckeln är det här noden som ska tas bort annars: # Nod med endast ett barn eller inget barn om root.left är Ingen: return root.right elif root.right är Ingen: return root.left # Nod med två barn: Hämta efterföljaren i ordningsföljden (minst i det högra underträdet) root.key = self.minValue(root.right) # Ta bort efterföljaren root.right = self.deleteNode(root.right, root.key) returnera root def minValue(self, root): minv = root.key medan root.left: minv = root.left.key root = root.left returnera minv # Drivrutinskod om __name__ == '__main__': tree = BinaryTree() # Låt oss skapa följande 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('Original BST:', end=' ') tree.inorder(tree.root) print() print ('
Ta bort en lövnod: 20') tree.root = tree.deleteNode(tree.root, 20) print('Ändrad BST-träd efter borttagning av lövnod:') tree.inorder(tree.root) print() print('
Ta bort nod med enstaka barn: 70') tree.root = tree.deleteNode(tree.root, 70) print('Ändrad BST-träd efter borttagning av enstaka nod:') träd. inorder(tree.root) print() print('
Ta bort nod med båda underordnade: 50') tree.root = tree.deleteNode(tree.root, 50) print('Ändrad BST-träd efter borttagning av båda underordnade noden :') 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 = Infoga(nod.höger, nyckel); // returnera den (oförändrade) nodpekarens returnod; } // En verktygsfunktion för att göra inorderpassering av BST public void Inorder(Nodrot) { if (root != null) { Inorder(root.left); Console.Write(root.key + ' '); Inorder(root.right); } } // Givet ett binärt sökträd och en nyckel, tar den här funktionen bort nyckeln och returnerar den nya offentliga rotnoden DeleteNode(Nodrot, int nyckel) { // Base case if (root == null) return root; // Om nyckeln som ska raderas är mindre än rotens nyckel, så ligger den i det vänstra underträdet om (nyckel< 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, nyckel); // Om nyckeln är densamma som rotnyckeln, så är detta noden som ska tas bort annars { // Nod med endast ett underordnat eller inget underordnat om (root.left == null) returnerar root.right; else if (root.right == null) returnerar root.left; // Nod med två barn: Hämta efterföljaren i ordningsföljden (minst i det högra underträdet) root.key = MinValue(root.right); // Delete the inorder successor root.right = DeleteNode(root.right, root.key); } returnera rot; } public int MinValue(Nodrot) { int minv = rot.nyckel; while (root.left != null) { minv = root.left.key; root = root.left; } returnera minv; } // Driver Code public static void Main(string[] args) { BinaryTree tree = new BinaryTree(); /* Låt oss skapa följande 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('Original BST: '); träd.Inorder(träd.rot); Console.WriteLine(); Console.WriteLine('
Ta bort en lövnod: 20'); tree.root = tree.DeleteNode(tree.root, 20); Console.Write('Modifierat BST-träd efter borttagning av Leaf Node:
'); träd.Inorder(träd.rot); Console.WriteLine(); Console.WriteLine('
Ta bort nod med enskilt barn: 70'); tree.root = tree.DeleteNode(tree.root, 70); Console.Write('Ändrad BST-träd efter borttagning av enstaka underordnade Nod:
'); träd.Inorder(träd.rot); Console.WriteLine(); Console.WriteLine('
Ta bort nod med båda underordnade: 50'); tree.root = tree.DeleteNode(tree.root, 50); Console.Write('Ändrad BST-träd efter borttagning av båda underordnade Node:
'); träd.Inorder(träd.rot); }> 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>node.key) node.right = this.insert(node.right, nyckel); // returnera den (oförändrade) nodpekarens returnod; } // En verktygsfunktion för att göra inorderövergång av BST inorder(node) { if (nod !== null) { this.inorder(node.left); console.log(nod.nyckel + ' '); this.inorder(node.right); } } // Givet ett binärt sökträd och en nyckel, tar denna funktion bort nyckeln och returnerar den nya roten deleteNode(root, key) { // Base case if (root === null) return root; // Om nyckeln som ska raderas är mindre än rotens nyckel, så ligger den i det vänstra underträdet om (nyckel< 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, nyckel); // Om nyckel är samma som roots nyckel, då är detta noden som ska tas bort annars { // Nod med endast ett underordnat eller inget underordnat om (root.left === null) returnerar root.right; else if (root.right === null) returnerar root.left; // Nod med två barn: Hämta efterföljaren i ordningsföljden (minst i det högra underträdet) root.key = this.minValue(root.right); // Ta bort efterföljaren root.right = this.deleteNode(root.right, root.key); } returnera rot; } minValue(nod) { låt minv = nod.nyckel; while (node.left !== null) { minv = node.left.key; nod = nod.vänster; } returnera minv; } } // Driver Code let tree = new BinaryTree(); /* Låt oss skapa följande 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('Original BST:'); tree.inorder(träd.rot); console.log('
Ta bort en lövnod: 20'); tree.root = tree.deleteNode(tree.root, 20); console.log('Ändrad BST-träd efter borttagning av Leaf Node:'); tree.inorder(träd.rot); console.log('
Ta bort nod med enskilt barn: 70'); tree.root = tree.deleteNode(tree.root, 70); console.log('Ändrad BST-träd efter borttagning av enskild nod:'); tree.inorder(träd.rot); console.log('
Ta bort nod med båda underordnade: 50'); tree.root = tree.deleteNode(tree.root, 50); console.log('Ändrad BST-träd efter borttagning av båda underordnade Node:'); tree.inorder(träd.rot);> Produktion
Original BST: 20 30 40 50 60 70 Delete a Leaf Node: 20 Modified BST tree after deleting Leaf Node: 30 40 50 60 70 Delete Node with single child: 70 Modified BST tree after deleting single child No...>
Tidskomplexitet: O(h), där h är höjden på BST.
Hjälputrymme: På).
Relaterade länkar: