重写数据结构--二叉搜索树

性质：

根节点左边的节点关键字都比根节点的关键字小；根节点右边的节点关键字都比根节点的关键字大；

结构体：

typedef struct BinarySearchTreeNode {
int value;
BinarySearchTreeNode* parent;
BinarySearchTreeNode* left;
BinarySearchTreeNode* right;
}BinarySearchTreeNode;

按序输出：

中序遍历（复杂度为O(n)）：

void InOrder(BinarySearchTreeNode* root) {
if (root != NULL) {
InOrder(root->left);
cout << root->value << " ";
InOrder(root->right);
}
}

查找元素：

（递归实现）

BinarySearchTreeNode* Search(BinarySearchTreeNode* root, int x) {
if (root == NULL || x == root->value) { //感觉这句好机智
return root;
} else {
if (x > root->value) {
return Search(root->right, x);
} else {
return Search(root->left, x);
}
}
}

（非递归实现）

BinarySearchTreeNode* Search_(BinarySearchTreeNode* root, int x) {
while( root!= NULL && x != root->value) {
if (x > root->value) {
root = root->right;
} else {
root = root->left;
}
}
return root;
}

最小元素和最大元素：

//最小
BinarySearchTreeNode* Min(BinarySearchTreeNode* root) {
BinarySearchTreeNode* ans = NULL;
while (root != NULL ) {
ans  = root;
root = root->left;
}
return ans;
}

//最大
BinarySearchTreeNode* Max(BinarySearchTreeNode* root) {
BinarySearchTreeNode* ans = NULL;
while (root != NULL ) {
ans  = root;
root = root->right;
}
return ans;
}

寻找前驱和后继：

《算法导论》给出了一个找后继的例子：

如果该节点有右子树，直接返回右子树的最小值；

否则沿着该节点向上找双亲，找到一个节点，这个节点是它的双亲的左子树，就返回它的双亲；

但是我觉得更直观的理解是不断向上找双亲，然后直接比较关键字，遇到第一个关键字比寻找的元素大，就终止返回；

他那样写一定有他的理由，因为是直观的去按照中序遍历的思路去寻找，肯定是很完备的；只是目前我找不出我的思路的错误

//算法导论上的实现
BinarySearchTreeNode* FindSuccessor(BinarySearchTreeNode* root) {
if (root->right != NULL) {
return Min(root->right);
} else {
BinarySearchTreeNode* ans = root.parent;
while(ans != NULL && root == ans->right) {
root = ans;
ans  = ans->parent;
}
return ans;
}
}

寻找前驱应该是对称的；

插入和删除：

插入：

首先传入的树根一定是引用，其次，先建立一个临时节点便于之后插入，向下索引时（插入的位置一定是NULL），所以要同时记录插入位置的双亲节点，然后再根据大小关系判断插入。

void Insert(BinarySearchTreeNode* &root, int z) {

BinarySearchTreeNode* temp = new BinarySearchTreeNode;
temp->value = z;
temp->parent = temp->left = temp->right = NULL;

BinarySearchTreeNode* index = root;
BinarySearchTreeNode* index_parent = NULL;
while(index != NULL) {
index_parent = index;
if (temp->value > index->value) {
index = index->right;
} else {
index = index->left;
}
}
temp->parent = index_parent;
if (index_parent == NULL) {
root = temp;
} else if (temp->value > index_parent->value) {
index_parent->right = temp;
} else {
index_parent->left = temp;
}

}

删除：

被删除节点为z

分三种情况：

z没有孩子，直接删除，并修改双亲结点指向z的指针为NULL

z只有一个孩子，将孩子提到z的位置，并修改双亲结点指向z的指针为z的孩子

z有两个孩子，先找z的后继，如果后继不是z的右子树的根节点，先把后继换到右子树的根节点；接着，把后继提上来，再改变后继的左子树为z的左子树

替换的子过程：

//以v为根的子树替换一棵以u为根的子树，此时u作为一个单独的节点保留自己的信息，但是独立出这棵树了
void TransPlant(BinarySearchTreeNode* & root, BinarySearchTreeNode* u, BinarySearchTreeNode* & v) {
if(u->parent == NULL) {
root = v;
} else {
BinarySearchTreeNode* & Parent = u->parent;
if (u == Parent->left) {
Parent->left = v;
} else {
Parent->right = v;
}
}
if (v != NULL) {
v->parent = u->parent;
}
}

删除节点：

void Delete(BinarySearchTreeNode* &root, BinarySearchTreeNode* z) {     //如果传入的参数是int,那就调用一次Search
if (root == NULL) {
cout << "Already empty!" << endl;
return;
}
if (z == NULL) {
cout << "Not exist!" << endl;
return;
}
if (z->left == NULL) {
TransPlant(root, z, z->right);
} else if (z->right == NULL) {
TransPlant(root, z, z->left);
} else { //上两种情况是只有一个子树，或者没有子树，下面的情况是有两个子树
BinarySearchTreeNode* y = Min(z->right);
if (y->parent != z) {   //如果y不是z的右子树, 把y换到z的右子树
TransPlant(root, y, y->right);
y->right = z->right;
y->right->parent = y;
}

TransPlant(root, z, y);
y->left = z->left;
y->left->parent = y;
}
}

再次考虑到，什么时候该用引用呢？当需要在函数中改变参数的时候，传参就加上引用；但是遇到很多遍历的情况，会经常不知所措，所以目前采取的策略是，在确保不会错的情况下，只要函数里对这个变量有赋值的操作，我都会加上引用；

构建随机二叉搜索树：

将n个不同的关键字按照随机次序单纯使用插入操作建树；

一个有n个不同关键字的随机构建二叉搜索树的期望高度为log(n)

双亲的意义：

用来寻找前驱和后继；

和堆&优先队列的区别

堆是左右子树的根节点都会比双亲节点大，并且优先队列插入和删除的操作是不断交换的过程