【数据结构】搜索树

二叉搜索树

Binary Search Tree

 

静态查找， 动态查找

无序链表：灵活性好

有序数组：效率高

直接把元素放在树上，树的动态性强。

这种方式查找，即灵活又效率高。

 

二叉搜索树，又称有序二叉树，排序二叉树

顾名思义用来排序，何以排序，键值比大小

键 ： key  排序用的是key，权值

值  ：value  有意义的数据

性质：

1.非空左子树的键值均小于根结点；

2.非空右子树的键值小均于根结点；

3.左，右子树都是二叉树。

 

构造结点

    老规矩，树形数据结构先来构造结点-》 注意多出了key 与 value

template 

struct BinarySearchTreeNode

{

        K _k;

         V _v;

        BinarySearchTreeNode* _left;

        BinarySearchTreeNode* _right;

        BinarySearchTreeNode(const K& k, const V& v)

               : _k(k)

                 : _v(v)

               , _left(NULL)

               , _right(NULL)

        {}

};

 

基本操作：

查找操作：key的作用是来排序，所以用它来查找，循环比较结点的key，小进入左子树，大进入右子树

相等时返回key 或 value

 

Node* Find（const T& x, Node* root）

{

    if (root == NULL)

        return NULL;

    if ( x == root->_t)

        return root;

    if ( x < root->_t)

        return Find(root->_left);  //尾递归 可以用循环来实现

    else ( x > root->_t)

        return Find(root->_right);

    else 

        error(flase);

}

 

找最值元素 ： 根据他的概念不难知道

最大元素一定在最右边

最小元素一定在最左边

 

Node* FindMin(Node* root)

{

    while(root)

    {

        if (root->left)

            root = root->left;

    }

    return NULL;

}

结点的插入： 1.首先找到他所在的位置，类似查找函数

                     2判断有没有相同的key值，如果有更新

                     3.没有，就直接插入

bool Insert(const K& k)

        {

               Node* root = _root;

               Node* par = root;

               if (_root == NULL)

               {

                       _root = new Node(k);

                       //_root = root;

                       return true;

               }

               while (root)

               {

                       if (k < root->_k)

                       {

                              par = root;

                              root = root->_left;

                       }

                       else if (k > root->_k)

                       {

                              par = root;

                              root = root->_right;

                       }

                       else

                              return false;

               }

               if (k < par->_k)

                       par->_left = new Node(k);

               else

                       par->_right = new Node(k);

               return true;

        }

 

结点的删除 -》删除操作是很重要的操作，要不能影响其他的节点，具体为三种情况。

1.叶子结点，直接删除，置空

2.只有一个孩子结点，删除自己，父亲指向自己孩子

3.有俩个孩子结点，在左子树里找一个最大的数 或在右子树里找一个最小的树替换 转换为1 2种情况。

why： 因为右子树的最小值一定不会有俩个儿子，这样交换之后可以删除。

           何为右子树的最小值，上面有讲最值问题，最左边的节点一定最小。交换之后，因为他是从右子树交换上来所以一定比左树的值都大，又是比右树都小的，所以不影响。

bool Removed(const K& k)

        {

               Node* root = _root;

               Node* par = _root;

               if (!root)

                       return false;

               while (root)

               {

                       if (k < root->_k)

                       {

                              par = root;

                              root = root->_left;

                       }

                       else if (k > root->_k)

                       {

                              par = root;

                              root = root->_right;

                       }

                       else if (k == root->_k)

                              break;

               }

               if (!root)

                       return false;

               //1,当他为叶子结点时，直接删

               if (root->_left == NULL && root->_right == NULL)

               {

                       if (par->_left == root)

                              par->_left = NULL;

                       else if (par->_right == root)

                              par->_right = NULL;

                       /*else

                              error(false);*/

                       delete root;

                       return true;

               }

               //2.当他左树不为空时，找出左树中最大节点为交换值，删除

               if (root->_left != NULL)

               {

                       par = root;

                       Node* cur = root->_left;

                       while (cur->_right)

                       {

                              par = cur;

                              cur = cur->_right;

                       }

                       _Swap(root, cur);

                       if (par->_left == cur)

                              par->_left = cur->_left;

                       else if (par->_right == cur)

                              par->_right = cur->_left;

                       delete cur;

               }

               //3,只有右子树

               else if (root->_right != NULL)

               {

                       if (root == par->_left)

                              par->_left = root->_right;

                       else if (par->_right == root)

                              par->_right = root->_right;

                       delete root;

               }

        }

 

效率分析

    我们不难看出当某一端高度过高时，运行时间会变慢，为了让高度相近，就为平衡树。

    当插入顺序最好时，为平衡树，此时效率最高为lgn；

    所以 如何BST树构造为平衡数才是重点。