二叉搜索树原理及实现

二叉搜索树

性质

1. 若任意节点的左子树不为空，则左子树的所有节点值均小于根节点的值；
2. 若任意节点的右子树不为空，则右子树的所有节点值均大于跟节点的值；
3. 任意节点的左、右子树也分别为二叉查找树；
4. 没有键值相等的节点。

通常采用二叉链表作为二叉查找树的存储结构：

 struct BiTree {
        int key;
        BiTree *lChild;
        BiTree *rChild;
        BiTree(int _key): key(_key), lChild(null), rChild(null);
    };
    typedef *BiTree BiTree;

查找

1. 若树为空，则退出，返回false；
2. 若值==当前节点的值，return true；
3. 若值<当前节点的值，则在左子树中继续查找；
4. 否则，右子树继续查找

   bool seachTree(BiTree T, int key, BiTree f, BiTree& p) {
        if (!T)
            p = f;
            return false;
        if (T->key == key) {
            P = T;
            return true;
        }
        else if (key < T->key) {
            seachTree(T->lChild, key, T, p);
        } else
            seachTree(T->rChild, key, T, p);
    }

插入(创建)

1. 若b是空树，则将s所指节点作为根节点插入，否则
2. 若元素值==节点的元素值，则返回false（规则：节点中不允许出现元素相等的情况）；
3. 若s->data < 节点值，则插入到左子树中；
4. 否则，插入到右子树中 ；
5. 新插入节点总是叶子节点。

 bool insertTree(BiTree T, int e) {
        if (!T) {
            BiTree s = new BiTree();
            s->data = e;
            s->lChild = s->rChild = NULL;
        } else if (s->data == T->data) {
            return false;
        } else if (s->data > T->data) {
            insertTree(T->rChild, e);
        } else {
            insertTree(T->lChild, e);
        }
    }

删除

有三种情况：

1. 若删除的为叶子节点，直接删除即可；
2. 若删除的只有左子树PL或只有右子树PR：
3. 若删除的节点左子树和右子树均不为空，利用中序遍历的方法，

前序遍历

先访问根节点，再访问左节点，再访问右节点

 void preOrder_traversal(TreeNode *root) {
        cout << root->data;
        if (root->lChild != NULL) {
            preOrder_travesal(root->lChild);
        }
        if (root->rChild != NULL) {
            preOrder_travesal(root->rChild);
        }
    }

中序遍历

1. 先找到左节点；
2. 再找根节点；
3. 再找右节点。

 void inOrder_traversal (TreeNode *root) {
        if (root->lChild != NULL) {
            inOrder_traversal(root->lChild);
        }
        cout << root->data;
        if (root->rChild != NULL) {
            inOrder_traversal(root->rChild);
        }
    }

后序遍历

1. 先找左节点，再找右节点，再找根节点

void postOrder_traversal (TreeNode *root) {
        if (root->lChild != NULL) {
            postOrder_traversal(root->lChild);
        }
        if (root->rChild != NULL) {
            postOrder_traversal(root->rChild);
        }
        cout << root->data;
    }