数据结构二叉树

二叉树

template<typename T>
class binTree {
private:
    struct Node {
        T data;
        Node* left;
        Node* right;
        Node(Node* l = nullptr, Node* r = nullptr) {
            left = l;
            right = r;
        }
    };
    Node* root;
    int size;
    void CreateBinTree(Node* root);
    void DestroyBinTree(Node* root);
public:
    binTree();
    ~binTree();
    //前序
    void PreOrder(Node& root);
    //中序
    void InOrder(Node& root);
    //后序
    void PostOrder(Node& root);
    //层序
    //void LevelOrder();
    //结点数
    int GetNodeCount() {
        return size;
    }
    //高度
    int Height(Node& root);
    //是否平衡
    bool IsBalanceTree(Node& root);
    //叶子结点数
    int GetLeafNodeCount(Node& root);
    //K层结点数
    int GetKLevelNodeCount(Node& root, int k);
;

构建树

template<typename T>
void binTree<T>::CreateBinTree(binTree<T>::Node* root) {
    T c;
    std::cin >> c;
    if (c == '#') {
        root = nullptr;
    }
    else {
        root = new Node;
        root->data = c;
        CreateBinTree(root->left);
        CreateBinTree(root->right);
        ++size;
    }
}

销毁树

template<typename T>
void binTree<T>::DestroyBinTree(Node* root) {
    if (root != nullptr) {
        DestroyBinTree(root->left);
        DestroyBinTree(root->right);
        delete root;
    }
}

构造

template<typename T>
binTree<T>::binTree() {
    root = nullptr;
    size = 0;
    CreateBinTree(root);
}

析构

template<typename T>
binTree<T>::~binTree() {
    DestroyBinTree(root);
}

前序遍历

template<typename T>
void binTree<T>::PreOrder(binTree<T>::Node& root) {
    if (root != nullptr) {
        std::cout << root->data << "  ";
        PreOrder(root->left);
        PreOrder(root->right);
    }
}

中序遍历

template<typename T>
void binTree<T>::InOrder(binTree<T>::Node& root) {
    if (root != nullptr) {
        InOrder(root->left);
        std::cout << root->data << "  ";
        InOrder(root->right);
    }
}

后序遍历

template<typename T>
void binTree<T>::PostOrder(binTree<T>::Node& root) {
    if (root != nullptr) {
        PostOrder(root->left);
        PostOrder(root->right);
        std::cout << root->data << "  ";
    }
}

高度

template<typename T>
int binTree<T>::Height(Node& root) {
    if (root == nullptr) {
        return 0;
    }
    else {
        int lefth = Height(root->left);
        int righth = Height(root->right);
        return (lefth > righth ? lefth : righth) + 1;
    }
}

是否平衡：任一结点左右子树高度差不大于1

template<typename T>
bool binTree<T>::IsBalanceTree(Node& root) {
    if (root == nullptr) {
        return true;
    }
    else {
        int l = Height(root->left);
        int r = Height(root->right);
        if (sqrt(l - r) <= 1 && IsBalanceTree(root->left) 
            && IsBalanceTree(root->right)) {
            return true;
        }
        return false;
    }
}

叶子结点数

template<typename T>
int binTree<T>::GetLeafNodeCount(Node& root) {
    if (root == nullptr) {
        return 0;
    }
    else if (GetLeafNodeCount(root->left) == 0
        && GetLeafNodeCount(root->right) == 0) {
        return 1;
    }
    return 0;
}

第k层结点数

template<typename T>
int binTree<T>::GetKLevelNodeCount(binTree<T>::Node& root, int k) {
    if (root == nullptr) {
        return 0;
    }
    else if (k == 1) {
        return 1;
    }
    else {
        int left = GetKLevelNodeCount(root->left, k - 1);
        int right = GetKLevelNodeCount(root->right, k - 1);
        return left + right;
    }
}