Aku bertanya-tanya jika ada yang bisa membantu saya ulang metode ini untuk menemukan ketinggian pohon pencarian biner. Sejauh ini, kode saya terlihat seperti ini. Namun, jawaban yang saya'm mendapatkan lebih besar dari yang sebenarnya tinggi sebesar 1. Tapi ketika saya menghapus +1 dari saya kembali pernyataan, it's kurang dari ketinggian yang sebenarnya dengan 1. I'm masih mencoba untuk membungkus kepala saya sekitar rekursi dengan ini WIB. Setiap bantuan akan sangat dihargai.
public int findHeight(){
if(this.isEmpty()){
return 0;
}
else{
TreeNode<T> node = root;
return findHeight(node);
}
}
private int findHeight(TreeNode<T> aNode){
int heightLeft = 0;
int heightRight = 0;
if(aNode.left!=null)
heightLeft = findHeight(aNode.left);
if(aNode.right!=null)
heightRight = findHeight(aNode.right);
if(heightLeft > heightRight){
return heightLeft+1;
}
else{
return heightRight+1;
}
}
Masalahnya terletak pada basis kasus.
"tinggi pohon adalah panjang lintasan dari akar ke bagian terdalam node di pohon. A (berakar) pohon dengan hanya node (akar) memiliki ketinggian nol." - Wikipedia
Jika tidak ada node, anda ingin kembali -1 tidak 0. Hal ini karena anda menambahkan 1 pada akhir.
Jadi jika ada isn't node, anda kembali ke -1 yang membatalkan +1.
int findHeight(TreeNode<T> aNode) {
if (aNode == null) {
return -1;
}
int lefth = findHeight(aNode.left);
int righth = findHeight(aNode.right);
if (lefth > righth) {
return lefth + 1;
} else {
return righth + 1;
}
}
Ketinggian pohon pencarian biner adalah sama dengan jumlah lapisan - 1
.
Lihat diagram di http://en.wikipedia.org/wiki/Binary_tree
Anda rekursi adalah baik, jadi hanya kurangi satu di tingkat akar.
Perhatikan juga, anda dapat membersihkan fungsi sedikit dengan penanganan null node:
int findHeight(node) {
if (node == null) return 0;
return 1 + max(findHeight(node.left), findHeight(node.right));
}
Menurut saya, kode anda akan mendapat manfaat dari yang sederhana sedikit. Daripada mencoba untuk mengakhiri rekursi ketika anak pointer null, hanya berakhir ketika arus ** pointer null. Yang membuat kode yang lebih sederhana untuk menulis. Dalam pseudo-code, terlihat sesuatu seperti ini:
if (node = null)
return 0;
else
left = height(node->left);
right = height(node->right);
return 1 + max(left, right);
Hal ini belum teruji, tapi cukup jelas benar:
private int findHeight(Treenodeanoda) { jika (anoda.kiri == null && anoda.kanan == null) { return 0; // 1; rupanya simpul dengan tidak ada anak-anak yang memiliki ketinggian 0. } else if (anoda.kiri == null) { kembali 1 + findHeight(anoda.kanan); } else if (anoda.kanan == null) { kembali 1 + findHeight(anoda.kiri); } else { kembali 1 + max(findHeight(anoda.kiri), findHeight(anoda.kanan)); } }
Sering menyederhanakan kode anda lebih mudah daripada mencari tahu mengapa hal itu's off dengan satu. Kode ini adalah mudah untuk memahami: empat kemungkinan kasus-kasus yang jelas ditangani secara jelas cara yang benar:
class Solution{
public static int getHeight(Node root) {
int height = -1;
if (root == null) {
return height;
} else {
height = 1 + Math.max(getHeight(root.left), getHeight(root.right));
}
return height;
}
Berikut ini's ringkas dan mudah-mudahan cara yang benar untuk mengungkapkannya:
private int findHeight(TreeNode<T> aNode){
if(aNode == null || (aNode.left == null && aNode.right == null))
return 0;
return Math.max(findHeight(aNode.left), findHeight(aNode.right)) + 1;
}
Jika node saat ini adalah null, ada's tidak ada pohon. Jika kedua anak-anak, ada's satu lapisan, yang berarti 0 tinggi. Ini menggunakan definisi tinggi (disebutkan oleh Stephen) sebagai # lapisan - 1
public void HeightRecursive()
{
Console.WriteLine( HeightHelper(root) );
}
private int HeightHelper(TreeNode node)
{
if (node == null)
{
return -1;
}
else
{
return 1 + Math.Max(HeightHelper(node.LeftNode),HeightHelper(node.RightNode));
}
}
C# kode. Termasuk dua metode dalam BST kelas. anda membutuhkan dua metode untuk menghitung ketinggian pohon. HeightHelper menghitung, & HeightRecursive cetak dalam main().
public int height(){
if(this.root== null) return 0;
int leftDepth = nodeDepth(this.root.left, 1);
int rightDepth = nodeDepth(this.root.right, 1);
int height = leftDepth > rightDepth? leftDepth: rightDepth;
return height;
}
private int nodeDepth(Node node, int startValue){
int nodeDepth = 0;
if(node.left == null && node.right == null) return startValue;
else{
startValue++;
if(node.left!= null){
nodeDepth = nodeDepth(node.left, startValue);
}
if(node.right!= null){
nodeDepth = nodeDepth(node.right, startValue);
}
}
return nodeDepth;
}
Definisi yang diberikan di atas dari ketinggian adalah salah. Itu adalah definisi dari kedalaman.
"kedalaman dari sebuah node M di pohon adalah panjang lintasan dari akar pohon untuk M. Ketinggian pohon adalah salah satu lebih dari kedalaman terdalam node di pohon. Semua node kedalaman d pada tingkat d di pohon. Akar adalah simpul hanya pada level 0, dan kedalaman 0."
Kutipan: "Praktis Pengenalan Struktur Data dan Algoritma Analisis" Edition 3.2 (Versi Jawa) Clifford A. Shaffer Departemen Ilmu Komputer Virginia Tech Blacksburg, VA 24061
int height(Node* root) {
if(root==NULL) return -1;
return max(height(root->left),height(root->right))+1;
}
Mengambil ketinggian maksimum dari kiri dan subtree kanan dan tambahkan 1 untuk itu.Ini juga menangani kasus dasar(ketinggian Pohon dengan 1 node 0).
Mengatur tempHeight sebagai variabel statis(awalnya 0).
static void findHeight(Node node, int count) {
if (node == null) {
return;
}
if ((node.right == null) && (node.left == null)) {
if (tempHeight < count) {
tempHeight = count;
}
}
findHeight(node.left, ++count);
count--; //reduce the height while traversing to a different branch
findHeight(node.right, ++count);
}
Berikut ini adalah solusi di Jawa agak panjang tetapi bekerja..
public static int getHeight (Node root){
int lheight = 0, rheight = 0;
if(root==null) {
return 0;
}
else {
if(root.left != null) {
lheight = 1 + getHeight(root.left);
System.out.println("lheight" + " " + lheight);
}
if (root.right != null) {
rheight = 1+ getHeight(root.right);
System.out.println("rheight" + " " + rheight);
}
if(root != null && root.left == null && root.right == null) {
lheight += 1;
rheight += 1;
}
}
return Math.max(lheight, rheight);
}
//fungsi untuk menemukan ketinggian WIB
int height(Node* root) {
if(root == NULL){
return -1;
}
int sum=0;
int rheight = height(root->right);
int lheight = height(root->left);
if(lheight>rheight){
sum = lheight +1;
}
if(rheight > lheight){
sum = rheight + 1;
}
return sum;
}
Berikut ini adalah solusi dalam C#
private static int heightOfTree(Node root)
{
if (root == null)
{
return 0;
}
int left = 1 + heightOfTree(root.left);
int right = 1 + heightOfTree(root.right);
return Math.Max(left, right);
}
Saya kira pertanyaan ini bisa berarti dua hal yang berbeda...
int calcHeight(node* root){ if(akar==NULL) return 0; int l=calcHeight(akar->kiri); int r=calcHeight(akar->kanan); jika(l>r) kembali l+1; lain kembali r+1; }
2. Tinggi adalah total jumlah node dalam tree dirinya sendiri:
int calcSize(node* root){ if(akar==NULL) return 0; kembali(calcSize(akar->kiri)+1+calcSize(akar->kanan)); }
Untuk siapapun yang membaca ini!!!!
TINGGI didefinisikan sebagai jumlah node di jalan terpanjang dari simpul akar ke simpul daun. Oleh karena itu: pohon dengan simpul akar memiliki ketinggian 1 dan 0.
TINGKAT node yang diberikan adalah jarak dari akar plus 1. Oleh karena itu: root pada level 1, anak node pada level 2 dan seterusnya.
(Courtesy informasi Struktur Data: Abstraksi dan Desain Menggunakan Java, Edisi 2, oleh Elliot B. Koffman & Paul A. T. Wolfgang) - Pesan yang digunakan dalam Struktur Data Saja saat ini saya mengambil di Columbus State University.