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

头文件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)