计算三叉搜索树的高度 - 华为OD统一考试

OD统一考试

分值： 100分

题解： Java / Python / C++

定义构造三叉搜索树规则如下: 每个节点都存有一个数，当插入一个新的数时，从根节点向下寻找，直到找到一个合适的空节点插入查找的规则是:

1.如果数小于节点的数减去500，则将数插入节点的左子树

2.如果数大于节点的数加上500，则将数插入节点的右子树

3.否则，将数插入节点的中子树

给你一系列数，请按以上规则，按顺序将数插入树中，构建出一棵三叉搜索树，最后输出树的高度。

输入描述

第一行为一个数N，表示有N个数，1<=N<=10000

第二行为N个空格分隔的整数，每个数的范围为[1,10000]

输出描述

输出树的高度(根节点的高度为1)

示例1

输入
5
5000 2000 5000 8000 1800
输出
3
说明
最终构造出的树如下，高度为3

示例2

输入
3
5000 4000 3000
输出
3
说明
最终构造出的树如下，高度为3

题解

模拟题

按题目要求规则直接构造树， 然后递归方式获取树的高度即可。

Java

import java.util.Scanner;

/**
 * @author code5bug
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Node root = new Node(scanner.nextInt());

        for (int i = 1; i < n; i++) root.insert(scanner.nextInt());

        System.out.println(root.getHeight());
    }
}

class Node {
    public int val;
    public Node left, mid, right;

    public Node(int val) {
        this.val = val;
    }

    /**
     * 新节点插入树中
     *
     * @param nval
     */
    public void insert(int nval) {
        if (nval < this.val - 500) {    // 则将数插入节点的左子树
            if (this.left != null) this.left.insert(nval);
            else this.left = new Node(nval);
        } else if (nval > this.val + 500) { // 则将数插入节点的右子树
            if (this.right != null) this.right.insert(nval);
            else this.right = new Node(nval);
        } else {    // 将数插入节点的中子树
            if (this.mid != null) this.mid.insert(nval);
            else this.mid = new Node(nval);
        }
    }

    /**
     * 获取树的高度
     *
     * @return
     */
    public int getHeight() {
        int maxHeight = 0;
        if (this.left != null) maxHeight = Math.max(maxHeight, this.left.getHeight());
        if (this.mid != null) maxHeight = Math.max(maxHeight, this.mid.getHeight());
        if (this.mid != null) maxHeight = Math.max(maxHeight, this.mid.getHeight());
        return maxHeight + 1;
    }

}

Python

class Node:
    def __init__(self, val) -> None:
        self.val = val
        self.left = None
        self.mid = None
        self.right = None

    # 新数（节点）插入树中
    def insert(self, nval: int):
        if nval < self.val - 500:  # 插左子树
            if self.left:
                self.left.insert(nval)
            else:
                self.left = Node(nval)
        elif nval > self.val + 500:  # 插右子树
            if self.right:
                self.right.insert(nval)
            else:
                self.right = Node(nval)
        else:   # 插中子树
            if self.mid:
                self.mid.insert(nval)
            else:
                self.mid = Node(nval)

    # 获取树的高度
    def getHeight(self) -> int:
        maxHeight = 0
        if self.left:
            maxHeight = max(maxHeight, self.left.getHeight())
        if self.mid:
            maxHeight = max(maxHeight, self.mid.getHeight())
        if self.right:
            maxHeight = max(maxHeight, self.right.getHeight())
        return maxHeight + 1


n = int(input())
arr = list(map(int, input().split()))
root = Node(arr[0])
for i in range(1, n):
    root.insert(arr[i])
print(root.getHeight())

C++

#include <iostream>
using namespace std;

class Node {
public:
    int val;
    Node* left;
    Node* mid;
    Node* right;
    Node(int val): val(val), left(nullptr), mid(nullptr), right(nullptr) {}

    // 析构函数
    ~Node() {
        delete left;
        delete mid;
        delete right;
    }

    void insert(int nval) {
        if (nval < val - 500) {
            if (left != nullptr) left->insert(nval);
            else left = new Node(nval);
        } else if (nval > val + 500) {
            if (right != nullptr) right->insert(nval);
            else right = new Node(nval);
        } else {
            if (mid != nullptr) mid->insert(nval);
            else mid = new Node(nval);
        }
    }

    int getHeight() {
        int maxHeight = 0;
        if (left != nullptr) maxHeight = max(maxHeight, left->getHeight());
        if (mid != nullptr) maxHeight = max(maxHeight, mid->getHeight());
        if (right != nullptr) maxHeight = max(maxHeight, right->getHeight());
        return maxHeight + 1;
    }
};



int main() {
    int n, val;
    cin >> n >> val;
    Node* root = new Node(val);
    for(int i=1; i<n; i++) {
        cin >> val;
        root->insert(val);
    }

    cout << root->getHeight() << endl;

    // 释放动态分配的内存
    delete root;

    return 0;
}

🙏整理题解不易， 如果有帮助到您，请给点个赞 ‍❤️‍ 和收藏 ⭐，让更多的人看到。🙏🙏🙏