二叉排序树

本次讨论的重点是 二叉排序树的插入删除（由此引入查找一般二叉树中结点的中序直接前驱和后继） 与一般二叉树的非递归遍历，对Hash查找（有冲突时）的平均长度也进行了深入的分析。

1 哈希表（散列）
       在基于“比较”的一系列查找方法中，记录的关键字和记录的相对位置之间没有确定的关系，查找效率依赖于比较次数。而哈希表查找是利用记录的关键字与它的存储位置之间的关系f（即Hash函数） ，不需比较便可直接取得所查记录，显然，哈希表存取比较方便，但是存储时容易产生冲突(collision): 即不同的关键字可以对应统一个地址。因此，如何确定hash函数和解决冲突是哈希表查找的关键。

1.1   Hash函数的构造方法
直接定址法： H(k)=key 或H(k)=a*key+b(线形函数) 例如

                     人口数字统计表（年龄作为关键字，哈希函数取关键字自身）

                     地址       1     2     3     …………       100

                     年龄       1     2     3     …………       100

                     人数       67    35    33    …………       244 

数字分析法：取关键字的若干数位组成哈希地址

如：关键字如下：若哈希表长为100则可取中间两位十进制数作为哈希地址。

81346532       81372242       81387422       ……       81354157 （划横线部分为地址）

平方取中法：关键字平方后取中间几位数组成哈希地址

除留余数法：取关键字被某个不大于表长m的数p除后所得的余数为哈希地址。

                     H(k) = k mod p      p<=m

折叠法，随机数法等

1.2   处理冲突的方法
         假设地址集为0..n-1,由关键字得到的哈希地址为j(0<=j<=n-1)的位置已存有记录,处理冲突就是为该关键字的记录找到另一个"空"的哈希地址。在处理中可能得到一个地址序列Hi i=1，2，...k 0<=Hi<=n-1),即在处理冲突时若得到的另一个哈希地址H1仍发生冲突,再求下一地址H2,若仍冲突,再求H3...。怎样得到Hi呢？

开放定址法：Hi=(H(k)+di) mod m  （H(k)为哈希函数；m为哈希表长；di为增量序列）

       当di=1，2，3，... m-1 时叫线性探测再散列。

       当di=12，-12，22，-22，32，-32，...,k2,-k2时叫二次探测再散列。

       当di=random（m）时叫伪随机探测序列。

例如：长度为11的哈希表关键字分别为17，60，29，哈希函数为H(k)=k mod 11,第四个记录的关键字为38，分别按上述方法添入哈希表的地址为8，4，3（随机数=9）。

再哈希法：Hi=RHi(key) i=1,2,...,k,其中RHi均为不同的哈希函数。

链地址法：这种方法很象基数排序，相同的地址的关键字值均链入对应的链表中。

建立公益区法：另设一个溢出表，不管得到的哈希地址如何，一旦发生冲突，都填入溢出表。

1.3查找分析
一般情况下，处理冲突方法相同的哈希表，其平均查找长度依赖于哈希表的装填因子a

                                              a=表中填入记录数 / 哈希表的长度，    

       a标志哈希表的装满程度。直观地看，a越小，发生冲突的可能性就越小；反之，a越大，表中已填入的记录越多，再填记录是，发生冲突的可能性就越大，则查找时，给定值需与之进行比较的关键字的个数也就越多。

 

以随机探测的一组公式进行分析推导：

长度为m的哈希表中装有n个记录时查找不成功的平均查找长度（相当于要在这张表中填入第n+1个记录时所需要的比较次数的期望值） 

       假定：哈希函数均匀（即产生表中各个地址的概率相等），处理冲突后产生的地址也是随机的。

pi：表示前i个哈希地址均发生冲突的概率

qi：表示需进行i次比较才能找到一个“空位”的哈希地址（即前i-1次发生冲突，第i次不冲突），那么：

 

 

 

 

2           二叉树
我们将讨论的二叉树分成三类：判定树，二叉排序树（搜索树），一般二叉树。

判定树：在折半查找时，我们依次比较的关键字的位置构成一个判定树，其节点的值就是记录在表中的位置。中序遍历判定树，就得到一个递增的有序序列。

二叉排序树：或者是一棵空树，或者是具有一下性质的二叉树：（1）若左子树不空，则左子树上所有节点的值均小于它的跟节点的值；（2）若右子树不空，则右子树上所有节点的值均大于他的跟节点的值；（3）它的左右子树分别也是二叉排序树

判定树与二叉排序树的联系是：中序都能得到有序序列，但是前者的节点值是位置，而后者的是关键字，并且，前者只是用于在折半查找是用于分析平均查找长度，并不是一个实实在在的树。

2.1二叉排序树的插入与删除
1、插入算法描述：

 

插入一个新的节点时，需要进行关键的比较，并且维护二叉排序树的性质。

int InsertBS ( BiTree T, Binode * x)
{
      /*在一棵已知二叉排序树中插入一个新的节点x*/
       if (T= = NULL) T = x;; /* 一直二叉排序树为空时 */
           return 1;
       else Binode* p = T,q;
       while(p!=NULL&&p.key!=x.key) /*只有在待插的节点关键字和树中某节点关键字不相等时，才进行相应的插入操作*/
       {
              if (p.key>x.key)
                     {q = p;
                     p = q->right;}
              else
                     {q = p;
                     p = q->left;}
       }
       if(q.key= =x.key)  ERROR(“The same key has existed!”);
       else
              if  (q.key>x.key)  {q->left = x; return 1;}  /*插入节点为左节点*/
              else         {q->right = x; return 1;}  /*插入节点为右节点*/
}
 

 

 

2、删除

删除操作分三种情况讨论：

（1）       删除节点p 为 叶子节点，则直接删除节点即可，不会破坏整棵树的结构。

（2）       删除节点p 不是叶子节点，只有左子树或者右子树，此时也可以直接修改其双亲节点的左子树或者右子树即可，作此修改也不会破坏二叉排序树的特性。

（3）       删除节点p的左右子树均不为空，此时，情况比较复杂一些，为保证二叉树的中序序列，可以有两种做法：其一是 令p的左子树为p的父亲节点的左子树，p的右子树为p的直接前驱的右子树。其二（我们讨论的）是令p的直接前驱（或者直接后继）替代p，然后从二叉树中删除它的直接前驱（或者直接后继）。

算法如下：

Void Delete ( BiTree &p)
{
       If (!p->right) /*右子树为空则重接左子树*/
              {q = p; p = p ->left; free (q);}
       Else  if (!p->left) /*左子树为空则重接右子树*/
              {q = p; p = p ->right; free (q);}
       Else /* 左右子树均不为空*/
              {q = p;
              s = p->left;
              while (s->right)   /* 左拐，然后向右走到尽头 */
              {
                     q = s;
                     s = s->right;
              }
              p.key = s.key;   /* s 指向被删除节点的前驱*/
              if(q!=p) q->right = s->left; /*重接q的右子树 */
              else q->left = s->left;    /*重接q的左子树 */
}

2.2 二叉树的中序直接前驱和直接后继
本来是讨论二叉排序树的删除操作的，结果经HZP一提醒，大家就进一步分析了如何找到给定节点的中序直接前驱和直接后继,不错不错，由深而广。

算法如下：

BiTree* findSuccssor( BiTree &p)
{
       If (p->right!=NULL) /*如果右子树，则其右子树的根节点就是其后继*/
              {return p->right;}
/*如右子树为空，则向上往左拐，到尽头节点为某个节点的左孩子，该节点就是后继*/
       q = p->parent;
                     While(q!=NULL&&p = = q->right)
                     {
                            p = q;
                            q = q->parent;
                     }
       Return q;
}
 
BiTree* findPredecessor( BiTree &p)
{
 If(p->left != NULL) /*如果左子树不为空，向左拐，向右走到尽头那个节点就是其前驱*/
       {
              q = p->left;
              While(q->right)
              { q = q->right; }
        Return q;
       }
 Else /*如左子树为空，则向上往右拐，到尽头节点为某个节点的右孩子，该节点就是前驱*/
       {
              q = p->parent;
              while(q!=NULL && p= = q->left)
              {
                            p = q;
                            q = q->parent;
              }
       Return q;
       }
}

 

2.3 一般二叉树的非递归遍历
二叉树的非递归遍历有两种思路：一种是用直接实现递归遍历，即递归遍历中的那些栈都显示实现；二是用比较自然的遍历思想，也用栈实现。

1 先序遍历

 

       preOrder1每次都将遇到的节点压入栈，当左子树遍历完毕后才从栈中弹出最后一个访问的节点，访问其右子树。在同一层中，不可能同时有两个节点压入栈，因此栈的大小空间为O(h)，h为二叉树高度。时间方面，每个节点都被压入栈一次，弹出栈一次，访问一次，复杂度为O(n) （LF原创）

 

Void preOrder1(BiTree* root)
{
       Stack S;
       While(root!=NULL || !S.empty())
       {   
              If(root!=NULL)
                     {
                            Visit(root); /*访问根节点*/
                            Push(root); /*将根节点入栈，目的是为了找右子树*/
                            root=root->left; /*依次访问左子树*/
                     }
              Else
                     {
                            root = S.pop(); /*回到父节点，*/
                            root = root->right; /*要开始访问右子树*/
                     }
       }
}

Void preOrder2(BiTree* root)
{
       If(root!=NULL)
       {
              Stack  S;
              Push(root);
              While(!S.empty())
              {
                     BiTree * node  = s.pop();
                     Visit(node); /*先访问根节点，无需压栈*/
                     S.push(node->right);
                     S.push(node->left);
              }
.      }
}

 

       preOrder2每次将节点压入栈，然后弹出，压右子树，再压入左子树，在遍历过程中，遍历序列的右节点依次被存入栈，左节点逐次被访问。同一时刻，栈中元素为m-1个右节点和1个最左节点，最高为h。所以空间也为O(h)；每个节点同样被压栈一次，弹栈一次，访问一次，时间复杂度O(n) （LF原创）

2         中序遍历

void InOrder1(TNode* root)
{
    Stack S;
    if( root != NULL )
    {
        S.push(root);
    }
    while ( !S.empty() )
    {
        TNode* node = S.pop();
        if ( node->bPushed )
        {   // 如果标识位为true,则表示其左右子树都已经入栈，那么现在就需要访问该节点了
            Visit(node);       
        }
        else
        {   // 左右子树尚未入栈，则依次将 右节点，根节点，左节点 入栈
            if ( node->right != NULL )
            {
                node->right->bPushed = false; // 左右子树均设置为false
                S.push(node->right);
            }
            node->bPushed = true;  // 根节点标志位为true
            S.push(node);
            if ( node->left != NULL )
            {
                node->left->bPushed = false;
                S.push(node->left);
            }
        }
    }
}

 

对比先序遍历，这个算法需要额外的增加O(n)的标志位空间。另外，栈空间也扩大，因为每次压栈的时候都压入根节点与左右节点，因此栈空间为O(n)。时间复杂度方面，每个节点压栈两次，作为子节点压栈一次，作为根节点压栈一次，弹栈也是两次,时间复杂度较高。

 

Void InOrder2(BiTree* root)
{
       Stack S;
       While(root!=NULL || !S.empty())
       {   
              If(root!=NULL)
                     {
                            Push(root);
                            root=root->left; /*左子树入栈*/
                     }
              Else
                     {
                            root = S.pop();
                            Visit(root); /*访问根节点*/
                            root = root->right; /*通过下一次想循环实现右子树遍历*/
                     }
       }
}

Inorde2类似于Preorder1，只是调换了一下节点的访问顺序。先序是先访问，再入栈，而中序是先入栈，弹栈后再访问。时空复杂度同先序一致。

3        后序遍历

void PostOrder(TNode* root)
{
    Stack S;
    if( root != NULL )
    {
        S.push(root);
    }
    while ( !S.empty() )
    {
        TNode* node = S.pop();
        if ( node->bPushed )
        {   // 如果标识位为true,则表示其左右子树都已经入栈，那么现在就需要访问该节点了
            Visit(node);        
        }
        else
        {   // 左右子树尚未入栈，则依次将 右节点,左节点,根节点 入栈
            if ( node->right != NULL )
            {
                node->right->bPushed = false; // 左右子树均设置为false
                S.push(node->right);
            }
            if ( node->left != NULL )
            {
                node->left->bPushed = false;
                S.push(node->left);
            }
            node->bPushed = true;            // 根节点标志位为true
            S.push(node);
        }
    }
}

 

后序遍历只采用了我们讨论的非递归的第一种思想，即直接模拟递归调用的思想来完成。与中序类似，就是顺序调换一下，时间空间复杂度也一致。

 

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/kofsky/archive/2008/10/04/3015521.aspx