数据结构与算法(二叉查找树)

头文件SearchTree.hpp

#ifndef SearchTree_hpp
#define SearchTree_hpp

#include <stdio.h>

struct Node;
typedef Node* SearchTree;
typedef Node* Position;
typedef int ElementType;

struct Node{
    ElementType element;
    SearchTree left;
    SearchTree right;
};

SearchTree MakeEmpty(SearchTree T);

Position find(ElementType e, SearchTree T);

Position findMin(SearchTree T);

Position findMax(SearchTree T);

SearchTree insert(ElementType e, SearchTree T);

SearchTree delet(ElementType e, SearchTree T);

void printSearchTree(SearchTree T);

#endif /* SearchTree_hpp */

源文件SearchTree.cpp

#include "SearchTree.hpp"
#include <stdlib.h>

//函数名字自解释，就不必多写什么注释了


SearchTree MakeEmpty(SearchTree T){
    if (!T) {
        return NULL;
    }
    else{
        MakeEmpty(T->left);
        MakeEmpty(T->right);
        free(T);
    }
    
    return NULL;
}

Position find(ElementType e, SearchTree T){
    if (!T) {
        return NULL;
    }
    else{
        if (e < T->element) {
            return find(e, T->left);
        }
        else if (e > T->element){
            return find(e, T->right);
        }
        else{
            return T;
        }
    }
}

//左子树比父亲小  右子树比父亲大
Position findMin(SearchTree T){
    if (!T) {
        return NULL;
    }
    if (!T->left) {
        return T;
    }
    else{
        return findMin(T->left);
    }
}

Position findMax(SearchTree T){
    if (!T) {
        return NULL;
    }
    if (!T->right) {
        return T;
    }
    else{
        return findMax(T->right);
    }

}

SearchTree insert(ElementType e, SearchTree T){
    if (!T) {
        T = (Node*)malloc(sizeof(Node));
        T->element = e;
        T->left = T->right = NULL;
    }
    else if (e < T->element){
        T->left = insert(e, T->left);
    }
    else if (e > T->element){
        T->right = insert(e, T->right);
    }
//    e == T->element被忽略了
    return T;
}

SearchTree delet(ElementType e, SearchTree T){
    if (!T) {
//   没有元素可删除报错
//        error;
    }
//    还没找到匹配元素
    else if (e < T->element){
        T->left = delet(e, T->left);
    }
    else if (e > T->element){
        T->right = delet(e, T->right);
    }
//    找到匹配元素了
//    匹配元素有两个孩子
    else if (T->left && T->right){
        Position tmp = findMin(T->right);
        T->element = tmp->element;
        T->right = delet(tmp->element, T->right);
    }
//    匹配元素一个孩子
    else{
        Position tmp = T;
        if (!T->left) {
            T = T->right;
        }
        else{
            T = T->right;
        }
        free(tmp);
    }
    
    return T;
}

void printSearchTree(SearchTree T){
//    中序遍历打印T的值
    if (!T) {
        return;
    }
    printSearchTree(T->left);
    printf("%d ", T->element);
    printSearchTree(T->right);
}

对于一颗深度为d的二叉树它的节点最大N = 2^0+2^1+2^2+...+2^(d-1)，所以d = log(N+1)。对于一颗有N个节点的二叉树它的深度最大可能为N,相当于一个链表；最小是log(N+1)，这是一颗完全二叉数。它的插入、删除操作的时间复杂度f(N)=O(logN)。我们可以通过求它的内部路径的总长D(N)，D(N)=O(NlogN),所以期望深度d=O(logN)