Metodo di dimensione per alberi binari

Question

Ho appena trovato questo codice per trovare la dimensione di un albero binario.

public int size() { 
    return(size(root)); 
} 
private int size(Node node) { 
    if (node == null) return(0); 
    else { 
    return(size(node.left) + 1 + size(node.right)); 
    } 
} 

Sono confuso perché è così che ci sono due metodi e uno senza argomento. Posso immaginare che sia una buona pratica ma non riesca a pensare al motivo.

Answer 1

OOPs suggerisce che è necessario scrivere la logica aziendale in metodo privato. Come per mio metodo di dimensione di visualizzazione con parametro è privato e la logica per il conteggio delle dimensioni è qui in modo che nessun altro su (al di fuori della classe) può modificare o accedere alla logica (tramite l'ereditarietà). Stai utilizzando un'altra dimensione per restituire questo metodo di dimensioni che ha un modificatore pubblico e l'altro utente userà quella classe per ottenere le dimensioni, in sostanza l'altro utente non sa come si calcola la dimensione.

Answer 2

Il metodo size che prende uno Node viene implementato in modo ricorsivo: trova la dimensione dell'albero da quello Node in basso. Questo non è utile al di fuori della classe dell'albero binario, quindi è private.

L'altro metodo size trova la dimensione dell'intero albero ei chiamanti non devono passare in un Node; l'albero binario sa già qual è la sua radice. Non è ricorsivo. Delega l'altro metodo size, passando lo root per ottenere la dimensione dell'intero albero. È molto utile al di fuori della classe, quindi è public.

Answer 3

Uno è public e uno è private. Quindi uno viene esposto e utilizzato esternamente senza parametri public int size() e l'altro viene utilizzato solo internamente e nascosto esternamente private int size(Node).

Questo concetto è chiamato incapsulamento ed è l'atto di nascondere dettagli interni che non hanno bisogno di essere esposti per il consumo generale, nel tentativo di semplificare l'utilizzo della classe (o libreria).

Answer 4

E anche quella con argomento è privata, ciò significa che posso solo usare qualcosa di simile

MyBinaryTree bt = new MyBinaryTree(); 
int treeSize = bt.size(); 

solito codice può avere commenti per sapere quello che sono pensati per. A volte un codice pulito non ha nemmeno bisogno di commenti.

/** 
* Gets the size of the current binary tree. 
*/ 
public int size() { 
    return(size(root)); 
} 
/** 
* Gets the size of the given branch 
* @param node The branch to count from. 
*/ 
private int size(Node node) { 
    if (node == null) return(0); 
    else { 
    return(size(node.left) + 1 + size(node.right)); 
    } 
} 

In teoria, tutti i rami con i bambini nell'albero binario possono anche essere gestiti come alberi binari.

noti che size() chiamerà la seconda con nodo radice come argomento, in questo caso significa conteggio a partire da una, internamente sarà.

Size of the tree is count of items from A 
Items from A are 1 + Items from B + Items from C 
Items from B are 1 
Items from C are 1 + Items from D + items from E 

Ora, perché dovresti usare uno method with the same name and diferent arguments?

Ci possono essere alcuni motivi per farlo o non farlo. Di solito significa che ci sono più modi per fare qualcosa o che vuoi usare qualcos'altro come predefinito, in questo caso size() userà come root di default.