#include<iostream>
#include<cstdio>
#include<cstdlib>
#define SIZE(a) ((sizeof(a)) / sizeof(a[0]))
using namespace std;
static int arr[] = { 1,5,4,3,2,6 };
typedef int Type;
typedef struct BST_Node {
Type key;
struct BST_Node *lchild;
struct BST_Node *rchild;
struct BST_Node *parent;
}Node, *BSTree;
void PreOrderTraverse(BSTree);//遍历
void InOrderTraverse(BSTree);
void PostOrderTraverse(BSTree);//删除打印
void bst_Destory(BSTree x);
void bst_Print(BSTree, Type, int);
BSTree bst_Search(BSTree, Type);//查找
BSTree bst_Search_iterative(BSTree, Type);
BSTree bst_minimum(BSTree);
BSTree bst_maximum(BSTree);//前驱后继
BSTree bst_pred(BSTree x);
BSTree bst_succ(BSTree x);
BSTree bst_Delete(BSTree, Type);//修改
BSTree bst_Insert(BSTree, Type);
void PreOrderTraverse(BSTree T) {
if (T) {
cout << T->key;
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
void InOrderTraverse(BSTree T) {
if (T) {
InOrderTraverse(T->lchild);
cout << T->key;
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(BSTree T) {
if (T) {
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout << T->key;
}
}
//Search by recursion
BSTree bst_Search(BSTree T, Type key) {
if (T == NULL || T->key == key)return T;
if (key < T->key)
return bst_Search(T->lchild, key);
else
return bst_Search(T->rchild, key);
}
BSTree bst_Search_iterative(BSTree T, Type key) {
while (T && T->key != key) {
if (key < T->key) T = T->lchild;
else T = T->rchild;
}
return T;
}
BSTree bst_minimum(BSTree T) {
if (!T) return NULL;
while (T->lchild != NULL) T = T->lchild;
return T;
}
BSTree bst_maximum(BSTree T) {
if (!T) return NULL;
while (T->rchild != NULL) T = T->rchild;
return T;
}
// 结点的后继结点等价于寻找BST中key大于该结点的最小结点
BSTree bst_succ(BSTree T) {
// 若x存在右孩子,则x的后继结点为以其右孩子为根的子树的最小结点
if (T->rchild)return bst_minimum(T->rchild);
/*若节点没有右孩子 则有两种可能
1:T为其父节点的左孩子,则其后继节点为其父亲
2:T为其父节点的右孩子,则寻找其父节点的父节点*/
BSTree P = T->parent;//
while (P && (T == P->rchild)) {//2
T = P;
P = P->parent;
}
return P;
}
//节点的前驱和后继恰好相反
BSTree bst_pred(BSTree T) {
if (T->lchild) return bst_maximum(T->lchild);
BSTree P = T->parent;
while ((P) && (T == P->lchild)) {
T = P;
P = P->parent;
}
return P;
}
static BSTree Create_BSTreeNode(Type key, BSTree parent, BSTree lchild, BSTree rchild) {
BSTree t;
if ((t = (Node *)malloc(sizeof(Node))) == NULL) return NULL;
t->key = key;
t->lchild = lchild;
t->rchild = rchild;
t->parent = parent;
return t;
}
static BSTree Insert(BSTree T, BSTree NODE) {
BSTree X = NULL;
BSTree Y = T;
while (X) {
Y = X;
if (NODE->key < X->key)
X = X->lchild;
else
X = X->rchild;
}
NODE->parent = Y;
if (Y == NULL) T = NODE;
else if (NODE->key < Y->key)
Y->lchild = NODE;
else Y->rchild = NODE;
return T;
}
BSTree bst_Insert(BSTree T, Type key) {
BSTree NODE;
if ((NODE = Create_BSTreeNode(key, NULL, NULL, NULL)) == NULL) return T;
return Insert(T, NODE);
}
static BSTree Delete(BSTree T, BSTree NODE) {
BSTree X = NULL;
BSTree Y = NULL;
if ((NODE->lchild == NULL) || (NODE->rchild == NULL)) Y = NODE;
else Y = bst_succ(NODE);
if (Y->lchild) X = Y->rchild;
else X = Y->rchild;
if (X) X->parent = Y->parent;
if (!Y->parent) T = X;
else if (Y == Y->parent->lchild) Y->parent->lchild = X;
else Y->parent->rchild = X;
if (Y != NODE) NODE->key = Y->key;
if (Y) free(Y);
return T;
}
BSTree bst_Delete(BSTree T, Type key) {
BSTree NODE;
if ((NODE = bst_Search(T, key)) != NULL) T = Delete(T, NODE);
return T;
}
void bst_Destory(BSTree T) {
if (!T)return;
if (T->lchild) bst_Destory(T->lchild);
if (T->rchild) bst_Destory(T->rchild);
free(T);
}
void bst_Print(BSTree T, Type key, int Direction) {
if (T) {
if (Direction == 0) cout << "root is " << T->key;
else cout << T->key << "is" << key << "'s" << Direction << "child";
bst_Print(T->lchild, T->key, -1);
bst_Print(T->rchild, T->key, 1);
}
}
int main() {
int i, len;
BSTree root = NULL;
cout << "Binary Search Tree";
len = SIZE(arr);
root = bst_Insert(root, 1);
cout << 1;
cout << "\n\nPreOrderTraverse: ";
PreOrderTraverse(root);
cout << "\nInOrderTraverse: ";
InOrderTraverse(root);
cout << "\nPostOrderTraverse: ";
PostOrderTraverse(root);
cout << "\nmax value is " << bst_maximum((root)) << endl;
cout << "\nmin value is " << bst_minimum((root)) << endl;
cout << "\nTraverse BST \n";
bst_Print(root, root->key, 0);
cout << "\nDelete root " << arr[3];
root = bst_Delete(root, arr[3]);
cout << "\nInOrderTraverse ";
InOrderTraverse(root);
bst_Destory(root);
system("pause");
return 0;
}