delezione in un albero binario di ricerca

Question

delezione in un albero binario di ricerca

voti

5

Mi è stato dato due alberi binari di ricerca. Ad esempio, A e B. In seguito, mi è stato chiesto di eliminare l'albero B dall'albero A.

Con la cancellazione, intendo eliminare tutti i nodi presenti in B da A. Nota: B non è necessariamente una sottostruttura di A.

es:
A:

      50   
     / \  
    10  75  
   /   / \  
  1   60   90

B:

     10
     / \
    1   75

albero risultante dovrebbe essere:

Due approcci sono venute in mente:
A1:
nodo * deleteTree (nodo * A, il nodo * B);
La radice dell'albero B. Eliminare questo nodo dall'albero A (da normale metodo di eliminazione BST). Successiva dividere il problema in due parti - per sottoalbero sinistro di B e sottoalbero destro di B. Per ciascuna della sottostruttura, recurse. Per il sottoalbero sinistro, il nodo che occupava il nodo che è stato eliminato dovrebbe servire come la radice per l'albero A. Per il sottoalbero destro, il successore simmetrico del nodo cancellato dovrebbe server come root per l'albero A.

A2: L'altro approccio è un po 'strano. Trovo l'ordine simmetrico e preordine attraversamento dell'albero A. Trovare ed eliminare tutti i nodi dell'albero B usando la ricerca binaria con la ricorsione (noi non modificare il preordine). Infine recostruct nostro BST dal inorder (restante) e il preordine (invariato).

Prob A: trovare un modo efficiente per BST.
Prob B: trovare un modo efficace per qualsiasi albero binario (non solo BST).

algorithm binary-tree binary-search-tree

È pubblicato 31/08/2011 alle 10:06
fonte dall'utente letsc

In altre lingue...

2 risposte

voti

0

Il mio modo di vedere, perché non si fa un attraversamento in ordine simmetrico di b. Quindi, finché la matrice non è vuota, fare un regolare eliminare da una per il valore dell'indice dell'array. Attraversamento è O (n) ed eliminazione di ciascun indice sarà O (log n). Totalmente, questa operazione sarà O (nlogn).

Risposto il 31/08/2011 a 10:27
fonte dall'utente Dhruv Gairola

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

problema A

Presumo i due alberi sono bilanciati.

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);
    }
}

Tempo di complessità:

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

Quindi la complessità generale è O (N) in base al teorema. La complessità spaziale è O (1) . Uno svantaggio è che destructed B.

PS: Non ho un'implementazione BST a portata di mano, quindi non posso testare il codice per voi. Ma penso che l'idea sia corretta.

problema B

Utilizzare tabella di hash per un albero e attraversare un'altra. Otterrete O (N) sia per il tempo e lo spazio complessità.