题解 | #树的高度#

#include <iostream>
using namespace std;

// 树节点类
class Node {
    int data;
    Node *leftChild;
    Node *rightChild;
public:
    Node() { leftChild = rightChild = NULL; }
    
    void setLeft(int d) {
        leftChild = new Node();
        leftChild->data = d;
    }
    
    void setRight(int d) {
        rightChild = new Node();
        rightChild->data = d;
    }
    
    void setData(int d) { data = d; }
    int getData() { return data; }
    Node* getLeftChild() { return leftChild; }
    Node* getRightChild() { return rightChild; }
    bool leftEmpty() { return leftChild == NULL; }
    bool rightEmpty() { return rightChild == NULL; }
};

// 二叉树类
class Tree {
    Node *root;
    
    // 递归删除节点
    void del(Node *r) {
        if(r == NULL) return;
        del(r->getLeftChild());
        del(r->getRightChild());
        delete r;
    }
    
    // 计算高度
    int height(Node* r) {
        if(r == NULL) return 0;
        if(r->leftEmpty() && r->rightEmpty()) return 1;
        int left = height(r->getLeftChild());
        int right = height(r->getRightChild());
        return max(left, right) + 1;
    }
    
    // 前序遍历寻找父节点
    bool preOrder(Node *r, const int &p, const int &c) {
        if(r == NULL) return false;
        if(r->getData() == p) {
            if(r->leftEmpty()) {
                r->setLeft(c);
                return true;
            }
            if(r->rightEmpty()) {
                r->setRight(c);
                return true;
            }
            return false;
        }
        return preOrder(r->getLeftChild(), p, c) || 
               preOrder(r->getRightChild(), p, c);
    }
    
public:
    Tree() { root = NULL; }
    ~Tree() { if(root != NULL) del(root); }
    
    // 连接节点
    void connect(const int &p, const int &c) {
        if(root == NULL) {
            root = new Node();
            root->setData(p);
            root->setLeft(c);
        } else {
            preOrder(root, p, c);
        }
    }
    
    // 获取树高
    int getHeight() {
        return height(root);
    }
};

int main() {
    int n;
    cin >> n;
    
    Tree tree;
    for(int i = 0; i < n-1; i++) {
        int parent, child;
        cin >> parent >> child;
        tree.connect(parent, child);
    }
    
    cout << tree.getHeight() << endl;
    return 0;
}

import java.util.*;

class Node {
    int data;
    Node left, right;
    
    Node(int data) {
        this.data = data;
        left = right = null;
    }
}

class Tree {
    Node root;
    
    Tree() {
        root = null;
    }
    
    void connect(int parent, int child) {
        if(root == null) {
            root = new Node(parent);
            root.left = new Node(child);
            return;
        }
        addNode(root, parent, child);
    }
    
    boolean addNode(Node node, int parent, int child) {
        if(node == null) return false;
        if(node.data == parent) {
            if(node.left == null) {
                node.left = new Node(child);
                return true;
            }
            if(node.right == null) {
                node.right = new Node(child);
                return true;
            }
            return false;
        }
        return addNode(node.left, parent, child) || 
               addNode(node.right, parent, child);
    }
    
    int getHeight() {
        return height(root);
    }
    
    int height(Node node) {
        if(node == null) return 0;
        return Math.max(height(node.left), height(node.right)) + 1;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        
        Tree tree = new Tree();
        for(int i = 0; i < n-1; i++) {
            int parent = sc.nextInt();
            int child = sc.nextInt();
            tree.connect(parent, child);
        }
        
        System.out.println(tree.getHeight());
    }
}

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

class Tree:
    def __init__(self):
        self.root = None
    
    def connect(self, parent, child):
        if not self.root:
            self.root = Node(parent)
            self.root.left = Node(child)
            return
        self._add_node(self.root, parent, child)
    
    def _add_node(self, node, parent, child):
        if not node:
            return False
        if node.data == parent:
            if not node.left:
                node.left = Node(child)
                return True
            if not node.right:
                node.right = Node(child)
                return True
            return False
        return (self._add_node(node.left, parent, child) or 
                self._add_node(node.right, parent, child))
    
    def get_height(self):
        return self._height(self.root)
    
    def _height(self, node):
        if not node:
            return 0
        return max(self._height(node.left), 
                  self._height(node.right)) + 1

def main():
    n = int(input())
    tree = Tree()
    
    for _ in range(n-1):
        parent, child = map(int, input().split())
        tree.connect(parent, child)
    
    print(tree.get_height())

if __name__ == "__main__":
    main()