sletting i et binært søketre

Question

sletting i et binært søketre

stemmer

5

Jeg har fått to binære søketrær. For eksempel, A og B. Deretter ble jeg bedt om å slette treet B fra treet A.

Ved sletting, mener jeg slette alle nodene som finnes i B fra A. Merk: B er ikke nødvendigvis et subtre av A.

f.eks:
A:

      50   
     / \  
    10  75  
   /   / \  
  1   60   90

B:

     10
     / \
    1   75

Resulterer treet skal være:

To tilnærminger kom til mitt sinn:
A1:
node * deleteTree (node * A, node * B);
Ta roten av treet B. Slett node fra treet A (ved normal BST sletting metode). Neste dele problem i to deler - for den venstre undertreet til B og den høyre subtre av B. For hver av undertreet, recurse. For venstre treet, bør noden som okkuperte noden som ble slettet tjene som roten til treet A. For den rette treet, den inorder følgeren slettet noden skal serveren som root for treet A.

A2: Den andre tilnærmingen er litt merkelig. Jeg finner inorder og forhåndsbestilling traversering av treet A. Finn og slette alle nodene i treet B ved hjelp av binære søk sammen med rekursjon (vi ikke endre forhåndsbestilling). Endelig recostruct vår bst fra inorder (gjenværende) og forhåndsbestilling (uendret).

Prob A: Finn en effektiv måte for BST.
Prob B: Finn en effektiv måte for noe Binary treet (ikke bare BST).

algorithm binary-tree binary-search-tree

Publisert på 31/08/2011 klokken 09:06
kilden bruker letsc

På andre språk...

2 svar

stemmer

0

Slik jeg ser det, hvorfor ikke gjøre en inorder traversering av b. Da, til matrisen ikke er tom, gjør et vanlig slette fra en for verdien i matrisen indeksen. Gjennomsøking er O (n) og sletting for hver indeks vil være O (LOGN). Helt, vil denne operasjonen være O (nlogn).

Svarte 31/08/2011 kl. 09:27
kilden bruker Dhruv Gairola

Mu Qiao · Accepted Answer · 2011-08-31 13:12

problem A

Jeg antar at de to trærne er balansert.

void deleteTree(node* A, node* B)
{
    if(A == NULL || B == NULL)
        return;

    if(A->data == B->data)
    {
        deleteTree(A->left, B->left);
        deleteTree(A->right, B->right);
        removeNode(A); // Normal BST remove
    }
    else if(A->data > B->data)
    {
        Node* right = B->right;
        B->right = NULL;
        deleteTree(A->left, B);
        deleteTree(A, right);
    }
    else // (A->data < B->data)
    {
        Node* left = B->left;
        B->left = NULL;
        deleteTree(A->right, B);
        deleteTree(A, left);
    }
}

Tid kompleksitet:

T(N) = 2 * T(N / 2) + O(1)

Slik at den totale kompleksiteten er O (N) i henhold til master-teorem. Plassen kompleksitet er O (1) . En ulempe er jeg destruert B.

PS: Jeg har ikke en BST implementering på hånden så jeg kan ikke teste koden for deg. Men jeg tror ideen er riktig.

problem B

Bruk nummertabellen for ett tre og krysse hverandre. Du vil få O (N) for både tid og rom kompleksitet.