Koska a BST , tehtävänä on poistaa solmu tästä BST , joka voidaan jakaa kolmeen skenaarioon:
Tapaus 1. Poista lehtisolmu BST:stä
Poisto BST:ssä
java jaettu merkkijono erottimella
Tapaus 2. Poista solmu, jossa on yksi lapsi BST:stä
Yhden lapsisolmun poistaminen on myös helppoa BST:ssä. Kopioi lapsi solmuun ja poista solmu .
Poisto BST:ssä
Tapaus 3. Poista solmu, jossa on molemmat lapset BST:stä
Solmun poistaminen molemmilla lapsilla ei ole niin yksinkertaista. Tässä meidän täytyy solmun poistaminen on sellainen tapa, että tuloksena oleva puu noudattaa BST:n ominaisuuksia.
Temppu on löytää solmun järjetön seuraaja. Kopioi järjestyksen seuraajan sisältö solmuun ja poista järjestyksen seuraaja.
Huomautus: Myös tilaajan edeltäjää voidaan käyttää.
Poistaminen binääripuussa
Huomautus: Järjestyksen seuraajaa tarvitaan vain silloin, kun oikea lapsi ei ole tyhjä. Tässä nimenomaisessa tapauksessa järjestyksen seuraaja voidaan saada etsimällä minimiarvo solmun oikeasta lapsesta.
Suositeltu käytäntö Solmun poistaminen BST:stä Kokeile!Poistotoiminnon toteutus BST:ssä:
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->avain = tuote; temp->vasen = temp->oikea = NULL; paluulämpötila; } // Aputoiminto BST:n inorder läpikulkuun void inorder(Solmu* root) { if (juuri != NULL) { inorder(root->left); printf('%d ', root->avain); inorder(juuri->oikea); } } /* Aputoiminto, joka lisää uuden solmun annetulla avaimella * BST */ Node* insert(Node* node, int key) { /* Jos puu on tyhjä, palauta uusi solmu */ if (solmu = = NULL) return newNode(avain); /* Muussa tapauksessa toista alas puussa */ if (avain< node->avain) solmu->vasen = insert(solmu->vasen, avain); else node->right = insert(solmu->oikea, avain); /* palauttaa (muuttumattoman) solmun osoittimen */ palauttaa solmun; } /* Binäärihakupuu ja avain tämä funktio poistaa avaimen ja palauttaa uuden juuren */ Solmu* deleteNode(Solmu* root, int k) { // Peruskirjain if (juuri == NULL) palauttaa juuren; // Jos poistettava avain on pienempi kuin juuren avain, // se sijaitsee vasemmassa alipuussa if (k< root->avain) { juuri->vasen = deleteSolmu(juuri->vasen, k); palauttaa juuri; } // Jos poistettava avain on suurempi kuin juuren avain, // se sijaitsee oikeassa alipuussa else if (k> juuri->avain) { juuri->oikea = deleteNode(root->right , k); palauttaa juuri; } // Jos avain on sama kuin pääkäyttäjän avain, tämä on poistettava solmu // Solmu, jolla on vain yksi lapsi tai ei yhtään lasta if (root->left == NULL) { Solmu* temp = juuri-> oikea; poista juuri; paluulämpötila; } else if (juuri->oikea == NULL) { Solmu* temp = juuri->vasen; poista juuri; paluulämpötila; } // Solmu kahdella lapsella: Hae järjestyksen seuraaja (pienin // oikeanpuoleisessa alipuussa) Solmu* succParent = juuri; Solmu* succ = juuri->oikea; while (succ->left != NULL) { succParent = succ; succ = succ->vasen; } // Kopioi järjestyksen seuraajan sisältö tähän solmuun root->key = succ->key; // Poista järjestyksen seuraaja if (succParent->left == succ) succParent->left = succ->right; muuten succParent->right = succ->right; poista succ; palauttaa juuri; } // Ohjainkoodi int main() { /* Luodaan seuraava BST 50 / 30 70 / / 20 40 60 80 */ Node* root = NULL; juuri = insert(juuri, 50); juuri = insert(juuri, 30); juuri = insert(juuri, 20); juuri = insert(juuri, 40); juuri = insert(juuri, 70); juuri = insert(juuri, 60); juuri = insert(juuri, 80); printf('Alkuperäinen BST: '); järjestys(juuri); printf('
Poista lehtisolmu: 20
'); juuri = deleteNode(juuri, 20); printf('Muokattu BST-puu lehtisolmun poistamisen jälkeen:
'); järjestys(juuri); printf('
Poista solmu yhdellä lapsilla: 70
'); juuri = deleteNode(juuri, 70); printf('Muokattu BST-puu yhden alisolmun poistamisen jälkeen:
'); järjestys(juuri); printf('
Poista solmu molemmilla lapsilla: 50
'); juuri = deleteNode(juuri, 50); printf('Muokattu BST-puu molempien alisolmujen poistamisen jälkeen:
'); järjestys(juuri); paluu 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->avain = tuote; temp->vasen = temp->oikea = NULL; paluulämpötila; } // Aputoiminto BST:n inorder läpikulkuun void inorder(struct Solmu* root) { if (juuri != NULL) { inorder(root->left); printf('%d ', root->avain); inorder(juuri->oikea); } } /* Aputoiminto, joka lisää uuden solmun annetulla avaimella BST:ssä */ struct Node* insert(struct Node* solmu, int avain) { /* Jos puu on tyhjä, palauta uusi solmu */ if (solmu == NULL) return newNode(avain); /* Muussa tapauksessa toista alas puussa */ if (avain< node->avain) solmu->vasen = insert(solmu->vasen, avain); else node->right = insert(solmu->oikea, avain); /* palauttaa (muuttumattoman) solmun osoittimen */ palauttaa solmun; } /* Binäärihakupuu ja avain tämä funktio poistaa avaimen ja palauttaa uuden juuren */ struct Node* deleteNode(struct Node* root, int k) { // Perustapaus if (root == NULL) return juuri; // Jos poistettava avain on pienempi kuin juuren avain, se sijaitsee vasemmassa alipuussa if (k< root->avain) { juuri->vasen = deleteSolmu(juuri->vasen, k); palauttaa juuri; } // Jos poistettava avain on suurempi kuin juuren avain, se sijaitsee oikeassa alipuussa else if (k> juuri->avain) { juuri->oikea = deleteNode(juuri->oikea, k ); palauttaa juuri; } // Jos avain on sama kuin pääkäyttäjän avain, tämä on poistettava solmu // Solmu, jolla on vain yksi lapsi tai ei yhtään lasta if (root->left == NULL) { struct Node* temp = root->oikea; vapaa(juuri); paluulämpötila; } else if (juuri->oikea == NULL) { struct Solmu* temp = juuri->vasen; vapaa(juuri); paluulämpötila; } // Solmu kahdella lapsella: Hanki järjestyksen seuraaja (pienin oikealla alipuulla) struct Solmu* succParent = juuri; struct Solmu* succ = juuri->oikea; while (succ->left != NULL) { succParent = succ; succ = succ->vasen; } // Kopioi järjestyksen seuraajan sisältö tähän solmuun root->key = succ->key; // Poista järjestyksen seuraaja if (succParent->left == succ) succParent->left = succ->right; muuten succParent->right = succ->right; vapaa (succ); palauttaa juuri; } // Ohjainkoodi int main() { /* Luodaan seuraava BST 50 / 30 70 / / 20 40 60 80 */ struct Node* root = NULL; juuri = insert(juuri, 50); insert(juuri, 30); insert(juuri, 20); insert(juuri, 40); insert(juuri, 70); insert(juuri, 60); insert(juuri, 80); printf('Alkuperäinen BST: '); järjestys(juuri); printf('
Poista lehtisolmu: 20
'); juuri = deleteNode(juuri, 20); printf('Muokattu BST-puu lehtisolmun poistamisen jälkeen:
'); järjestys(juuri); printf('
Poista solmu yhdellä lapsilla: 70
'); juuri = deleteNode(juuri, 70); printf('Muokattu BST-puu yhden alisolmun poistamisen jälkeen:
'); järjestys(juuri); printf('
Poista solmu molemmilla lapsilla: 50
'); juuri = deleteNode(juuri, 50); printf('Muokattu BST-puu molempien alisolmujen poistamisen jälkeen:
'); järjestys(juuri); paluu 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>solmu.avain) { solmu.oikea = insert(solmu.oikea, avain); } // palauttaa (muuttumattomana) solmun osoittimen paluusolmun; } // Aputoiminto BST:n inorder-läpikulkuun void inorder(Solmun juuri) { if (juuri != null) { inorder(root.left); System.out.print(root.key + ' '); inorder(root.right); } } // Binäärihakupuun ja -avaimen perusteella tämä funktio poistaa avaimen ja palauttaa uuden juuren Solmu deleteNode(Solmun juuri, int-avain) { // Peruskirjainkoko if (root == null) { return root; } // Jos poistettava avain on pienempi kuin juuren avain, se sijaitsee vasemmassa alipuussa if (avain< 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>juuri.avain) { juuri.oikea = deleteSolmu(juuri.oikea, avain); } // Jos avain on sama kuin pääkäyttäjän avain, tämä on poistettava solmu. else { // Solmu, jossa on vain yksi lapsi tai ei lainkaan ala-arvoa if (root.left == null) { return root.right; } else if (root.right == null) { return root.left; } // Solmu, jossa on kaksi lasta: Hanki järjestyksen seuraaja (pienin oikeanpuoleisessa alipuussa) root.key = minValue(root.right); // Poista järjestyksen seuraaja root.right = deleteNode(root.right, root.key); } palauttaa juuri; } int minArvo(Solmun juuri) { int minv = juuri.avain; while (root.left != null) { minv = root.left.key; juuri = root.left; } return minv; } // Ohjainkoodi public static void main(String[] args) { BinaryTree tree = new BinaryTree(); /* Luodaan seuraavat BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); puu.insert(puu.juuri, 30); puu.insert(puu.juuri, 20); puu.insert(puu.juuri, 40); puu.insert(puu.juuri, 70); puu.insert(puu.juuri, 60); puu.insert(puu.juuri, 80); System.out.print('Alkuperäinen BST: '); puu.inorder(puu.juuri); System.out.println(); System.out.println('
Poista lehtisolmu: 20'); puu.juuri = puu.deleteSolmu(puu.juuri, 20); System.out.print('Muokattu BST-puu lehtisolmun poistamisen jälkeen:
'); puu.inorder(puu.juuri); System.out.println(); System.out.println('
Poista solmu yhdellä lapsilla: 70'); puu.juuri = puu.deleteSolmu(puu.juuri, 70); System.out.print('Muokattu BST-puu yhden alisolmun poistamisen jälkeen:
'); puu.inorder(puu.juuri); System.out.println(); System.out.println('
Poista solmu molemmilla lapsilla: 50'); puu.juuri = puu.deleteSolmu(puu.juuri, 50); System.out.print('Muokattu BST-puu, kun molemmat alisolmut on poistettu:
'); puu.inorder(puu.juuri); } }> Python 3 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>solmu.avain: solmu.oikea = self.insert(solmu.oikea, avain) # palauttaa (muuttumattomana) solmun osoittimen return node # Aputoiminto, joka suorittaa BST:n inorder-läpikulkua def inorder(self, root): if root: self .inorder(root.left) print(root.key, end=' ') self.inorder(root.right) # Binäärihakupuun ja -avaimen perusteella tämä toiminto poistaa avaimen ja palauttaa uuden juuridef deleteNode (self, root, key): # Peruskirjainkoko, jos root on Ei mitään: palauta juuri # Jos poistettava avain on pienempi kuin juuren avain, se sijaitsee vasemmassa alipuussa 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) # Jos avain on sama kuin pääkäyttäjän avain, tämä on poistettava solmu muussa tapauksessa: # Solmu, jossa on vain yksi lapsi tai ei ollenkaan root.left on Ei mitään: return root.right elif root.right on Ei mitään: return root.left # Solmu jossa kaksi lasta: Hanki järjestyksen seuraaja (pienin oikeanpuoleisessa alipuussa) root.key = self.minValue(root.right) # Poista järjestyksen seuraaja root.right = self.deleteNode(root.right, root.key) return root def minValue(self, root): minv = root.key kun taas root.left: minv = root.left.key root = root.left return minv # Ohjainkoodi if __name__ == '__main__': tree = BinaryTree() # Luodaan seuraava BST # 50 # / # 30 70 # / / # 20 40 60 80 tree.root = puu.lisää(puu.juuri, 50) puu.lisä(puu.juuri, 30) puu.lisä(puu.juuri, 20) puu.lisä(puu.juuri, 40) puu.lisä(puu.juuri, 70) ) puu.lisää(puu.juuri, 60) puu.lisä(puu.juuri, 80) print('Alkuperäinen BST:', end=' ') tree.inorder(tree.root) print() print ('
Poista lehtisolmu: 20') tree.root = tree.deleteNode(tree.root, 20) print('Muokattu BST-puu lehtisolmun poistamisen jälkeen:') tree.inorder(tree.root) print() print('
Poista solmu yhdellä lapsilla: 70') tree.root = tree.deleteNode(tree.root, 70) print('Muokattu BST-puu yhden alisolmun poistamisen jälkeen:') puu. inorder(tree.root) print() print('
Poista solmu molemmilla lapsilla: 50') tree.root = tree.deleteNode(tree.root, 50) print('Muokattu BST-puu, kun molemmat alisolmut on poistettu :') puu.inorder(puu.juuri)> 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>solmu.avain) solmu.oikea = Insert(solmu.oikea, avain); // palauttaa (muuttumaton) solmun osoitin paluusolmun; } // Aputoiminto BST:n inorder-läpiviennille public void Inorder(Solmun juuri) { if (juuri != null) { Inorder(root.left); Console.Write(root.key + ' '); Inorder(root.right); } } // Binaarihakupuun ja -avaimen perusteella tämä toiminto poistaa avaimen ja palauttaa uuden juurihakemiston julkinen Solmu DeleteNode(Solmun juuri, int avain) { // Peruskirjainkoko if (root == null) return root; // Jos poistettava avain on pienempi kuin juuren avain, se sijaitsee vasemmassa alipuussa if (avain< 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 = PoistaSolmu(juuri.oikea, avain); // Jos avain on sama kuin pääkäyttäjän avain, tämä on poistettava solmu else { // Solmu, jossa on vain yksi lapsi tai ei aliosaa if (root.left == null) return root.right; else if (root.right == null) return root.left; // Solmu, jossa on kaksi lasta: Hanki järjestyksen seuraaja (pienin oikeanpuoleisessa alipuussa) root.key = MinValue(root.right); // Poista järjestyksen seuraaja root.right = DeleteNode(root.right, root.key); } palauttaa juuri; } public int MinArvo(Solmun juuri) { int minv = juuri.avain; while (root.left != null) { minv = root.left.key; juuri = root.left; } return minv; } // Ohjainkoodi public static void Main(string[] args) { BinaryTree tree = new BinaryTree(); /* Luodaan seuraavat BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.Insert(tree.root, 50); puu.Insert(puu.juuri, 30); puu.Insert(puu.juuri, 20); puu.Insert(puu.juuri, 40); puu.Insert(puu.juuri, 70); puu.Insert(puu.juuri, 60); puu.Insert(puu.juuri, 80); Console.Write('Alkuperäinen BST: '); puu.Inorder(puu.juuri); Console.WriteLine(); Console.WriteLine('
Poista lehtisolmu: 20'); puu.juuri = puu.PoistaSolmu(puu.juuri, 20); Console.Write('Muokattu BST-puu lehtisolmun poistamisen jälkeen:
'); puu.Inorder(puu.juuri); Console.WriteLine(); Console.WriteLine('
Poista solmu, jossa yksi lapsi: 70'); puu.juuri = puu.PoistaSolmu(puu.juuri, 70); Console.Write('Muokattu BST-puu yhden alisolmun poistamisen jälkeen:
'); puu.Inorder(puu.juuri); Console.WriteLine(); Console.WriteLine('
Poista solmu molemmilla lapsilla: 50'); puu.juuri = puu.PoistaSolmu(puu.juuri, 50); Console.Write('Muokattu BST-puu, kun molemmat alisolmut on poistettu:
'); puu.Inorder(puu.juuri); }> 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>solmu.avain) solmu.oikea = this.insert(solmu.oikea, avain); // palauttaa (muuttumaton) solmun osoitin paluusolmun; } // Aputoiminto BST:n inorder-läpikulkuun inorder(node) { if (node !== null) { this.inorder(node.left); console.log(solmu.avain + ' '); this.inorder(solmu.oikea); } } // Binäärihakupuun ja -avaimen perusteella tämä funktio poistaa avaimen ja palauttaa uuden juuren deleteSolmu(juuri, avain) { // Perustapaus if (root === null) return root; // Jos poistettava avain on pienempi kuin juuren avain, se sijaitsee vasemmassa alipuussa if (avain< 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); // Jos avain on sama kuin pääkäyttäjän avain, tämä on poistettava solmu else { // Solmu, jossa on vain yksi lapsi tai ei aliosaa if (root.left === null) return root.right; else if (root.right === null) return root.left; // Solmu, jossa on kaksi lasta: Hanki järjestyksen seuraaja (pienin oikeanpuoleisessa alipuussa) root.key = this.minValue(root.right); // Poista järjestyksen seuraaja root.right = this.deleteNode(root.right, root.key); } palauttaa juuri; } minArvo(solmu) { anna minv = solmu.avain; while (solmu.vasen !== null) { minv = solmu.vasen.avain; solmu = solmu.vasen; } return minv; } } // Ohjainkoodi let tree = new BinaryTree(); /* Luodaan seuraavat BST 50 / 30 70 / / 20 40 60 80 */ tree.root = tree.insert(tree.root, 50); puu.insert(puu.juuri, 30); puu.insert(puu.juuri, 20); puu.insert(puu.juuri, 40); puu.insert(puu.juuri, 70); puu.insert(puu.juuri, 60); puu.insert(puu.juuri, 80); console.log('Alkuperäinen BST:'); puu.inorder(puu.juuri); console.log('
Poista lehtisolmu: 20'); puu.juuri = puu.deleteSolmu(puu.juuri, 20); console.log('Muokattu BST-puu Leaf Node:n poistamisen jälkeen:'); puu.inorder(puu.juuri); console.log('
Poista solmu yhdellä lapsilla: 70'); puu.juuri = puu.deleteSolmu(puu.juuri, 70); console.log('Muokattu BST-puu yhden lapsisolmun poistamisen jälkeen:'); puu.inorder(puu.juuri); console.log('
Poista solmu molemmilla lapsilla: 50'); puu.juuri = puu.deleteSolmu(puu.juuri, 50); console.log('Muokattu BST-puu molempien alisolmujen poistamisen jälkeen:'); puu.inorder(puu.juuri);>>
Lähtö Aika monimutkaisuus: O(h), missä h on BST:n korkeus.
Aputila: Päällä). Liittyvät linkit: