//
// Created by Administrator on 2023/7/19.
//

#include <list>
#include <cstdio>
#include <vector>

/**
 *  二叉搜索树 左子树 永远比跟小 右子树 永远比根大
 *  搜索时与根与比较时左走右走
 */

template <class T>
struct tree_node {
    tree_node* left = nullptr;
    tree_node* right = nullptr;
    std::list<T> data;
};

template <class T>
class SearchTree {
public:
    explicit SearchTree(size_t len = 30)
    : root_node(new tree_node<T>()), size(0) {
        for (int i = 0; i < len; ++i) {
            node_barrel.push_back(new tree_node<T>());
        }
    }
    virtual ~SearchTree() {
        for (const auto &item: node_barrel) {
            delete item;
        }
        delete root_node;
    }

public:
    void insert(T data) {
        // 无可用节点
        if (size >= node_barrel.size() + 1) {
            for (int i = 0; i < node_barrel.size(); ++i) {
                node_barrel.push_back(new tree_node<T>());
            }
        }

        tree_node<T>* current = root_node;
        while (current != nullptr) {
            // 判断树节点是否有值
            if (current->data.empty()) {
                current->data.push_back(data);
                return;
            }
            // 值一致
            else if (current->data.front() == data){
                current->data.push_back(data);
                return;
            }
            // 值小
            else if (current->data.front() > data) {
                // 判断相应节点是否存在
                if (current->left == nullptr) {
                    // 连接新节点
                    current->left = node_barrel[size++];
                    current->left->data.push_back(data);

                    return;
                } else {
                    current = current->left;
                }
            }
            // 值大
            else if (current->data.front() < data) {
                // 判断相应节点是否存在
                if (current->right == nullptr) {
                    // 连接新节点
                    current->right = node_barrel[size++];
                    current->right->data.push_back(data);
                    return;
                } else {
                    current = current->right;
                }
            }
        }
    }


    tree_node<T>* find(T data) {
        tree_node<T>* current = root_node;
        while (current != nullptr) {
            if (current->data.front() == data) {
                return current;
            }
            else if(current->data.front() > data) {
                current = current->left;
            }
            else if(current->data.front() < data) {
                current = current->right;
            }
        }

        return nullptr;
    }

    void erase(T data) {
        // 待删除节点
        tree_node<T>* node = find(data);
        // 删除节点的左子树
        tree_node<T>* sub_tree_left = node->left;
        // 删除节点的右子树
        tree_node<T>* sub_tree_right = node->right;

        // 左子树 值
        T left_value = sub_tree_left->data.front();
        // 右子树 值
        T right_value = sub_tree_right->data.front();

        tree_node<T>* current = sub_tree_right;
        while (current != nullptr) {
            if (current->data.front() > left_value) {
                current
            }
        }
    }

    void update(T old_data, T new_data) {

    }

    const std::vector<tree_node<T> *> &nodeBarrel() const {
        return node_barrel;
    }

private:
    // 根节点
    tree_node<T>* root_node;
    // 节点桶
    std::vector<tree_node<T> *> node_barrel;
    // 有效节点大小
    size_t size;
};


int main() {
    SearchTree<int> searchTree;
    searchTree.insert(30);
    searchTree.insert(1);
    searchTree.insert(50);
    searchTree.insert(5);
    searchTree.insert(150);
    searchTree.insert(15);
    searchTree.insert(5);
    auto node = searchTree.find(5);
    for (const auto &item: node->data) {
        printf("%d ", item);
    }
}