第二十一次-查找(二)

折半查找

适用条件：

Ø 线性表中的记录必须按关键码有序；

Ø 必须采用顺序存储。

基本思想：

在有序表中（low, high,low<=high），

取中间记录作为比较对象，

若给定值与中间记录的关键码相等，则查找成功；

若给定值小于中间记录的关键码，则在中间记录的左半区继续查找；

若给定值大于中间记录的关键码，则在中间记录的右半区继续查找。

不断重复上述过程，直到查找成功，或所查找的区域无记录，查找失败。

int LineSearch :: BinSearch1(int k){

int mid, low = 1, high = length; //初始查找区间是[1, n]

while (low <= high) {//当区间存在时

mid = (low + high) / 2;

if (k < data[mid])

          high = mid - 1;
else if (k > data[mid])

           low = mid + 1; 
else

           return mid; //查找成功，返回元素序号
}

return 0; //查找失败，返回0

}

int LineSearch :: BinSearch2(int low,
int high, int k){

  if (low > high) 
return 0; //递归的边界条件

else {

int mid = (low + high) / 2;

if (k < data[mid])

       return BinSearch2(low, mid-1, k);
else if (k > data[mid])

       return BinSearch2(mid+1, high, k); 
else

       return mid; //查找成功，返回序号
}

}

折半查找判定树

判定树：折半查找的过程可以用二叉树来描述，

树中的每个结点对应有序表中的一个记录，

结点的值为该记录在表中的位置。

通常称这个描述折半查找过程的二叉树为折半查找判定树，简称判定树。

判定树的构造方法

⑴ 当n=0时，折半查找判定树为空；

⑵ 当n＞0时，

折半查找判定树的根结点为mid=(n+1)/2，

根结点的左子树是与有序表r[1] ~ r[mid-1]相对应的折半查找判定树，

根结点的右子树是与r[mid+1] ~ r[n]相对应的折半查找判定树。

二叉排序树（也称二叉查找树）：或者是一棵空的二叉树，或者是具有下列性质的二叉树：

⑴若它的左子树不空，则左子树上所有结点的值均小于根结点的值；

⑵若它的右子树不空，则右子树上所有结点的值均大于根结点的值；

⑶ 它的左右子树也都是二叉排序树。

#include

using namespace std;

template

struct BiNode{ DataType data; BiNode *lchild, *rchild; };

class BiSortTree {

public:

BiSortTree(int a[ ], int n); //建立查找集合a[n]的二叉排序树

~ BiSortTree( ){ Release(root); } //析构函数，同二叉链表的析构函数

void InOrder( ){InOrder(root);} //中序遍历二叉树

BiNode *InsertBST(int x) {return InsertBST(root, x);} //插入记录x

BiNode *SearchBST(int k) {return SearchBST(root, k);} //查找值为k的结点

void DeleteBST(BiNode *p, BiNode *f ); //删除f的左孩子p

private:

void Release(BiNode *bt);

BiNode *InsertBST(BiNode *bt , int x);

BiNode *SearchBST(BiNode *bt, int k);

void InOrder(BiNode *bt); //中序遍历函数调用

BiNode *root; //二叉排序树的根指针

};

void InsertBST(BiNode * &
root , BiNode *s);

分析：若二叉排序树为空树，则新插入的结点为新的根结点；否则，新插入的结点必为一个新的叶子结点，其插入位置由查找过程得到。

若二叉排序树为空树，则新插入的结点为新的根结点；

否则，如果插入的值比根节点值大，则在右子树中进行插入；否则，在左子树中进行插入。

递归。

void BiSortTree :: InOrder(BiNode *bt)

{

if (bt == nullptr) return; //递归调用的结束条件

else {

InOrder(bt->lchild); //前序递归遍历bt的左子树

cout << bt->data <<
" "; //访问根结点bt的数据域

InOrder(bt->rchild); //前序递归遍历bt的右子树

}

}

BiNode * BiSortTree :: SearchBST(BiNode
*bt, int k)

{

if (bt == nullptr) return nullptr;

if (bt->data == k) return bt;

else if (bt->data > k) return
SearchBST(bt->lchild, k);

else return SearchBST(bt->rchild, k);

}

BiNode *BiSortTree::InsertBST(BiNode
*bt, int x)

{

if (bt == nullptr) { //找到插入位置

BiNode *s = new BiNode;

s->data = x;

s->lchild = nullptr; s->rchild =
nullptr;

bt = s;

return bt;

}

else if (bt->data > x)
bt->lchild = InsertBST(bt->lchild, x);

else bt->rchild =
InsertBST(bt->rchild, x);

}

BiSortTree::BiSortTree(int a[ ], int n)

{

root = nullptr;

for (int i = 0; i < n; i++)

root = InsertBST(root, a[i]);

}

void BiSortTree::DeleteBST(BiNode *p,
BiNode *f )

{

if ((p->lchild == nullptr) &&
(p->rchild == nullptr)) { //p为叶子

f->lchild = nullptr; delete p;
return;

}

if (p->rchild == nullptr) { //p只有左子树

f->lchild = p->lchild; delete p;
return;

}

if (p->lchild == nullptr) { //p只有右子树

f->lchild = p->rchild; delete p;
return;

}

BiNode *par = p, *s = p->rchild; //p的左右子树均不空

while (s->lchild != nullptr) //查找最左下结点

{

par = s;

s = s->lchild;

}

p->data = s->data;

if (par == p) par->rchild =
s->rchild; //特殊情况，p的右孩子无左子树

else par->lchild = s->rchild;

delete s;

}

void BiSortTree :: Release(BiNode *bt)

{

if (bt == nullptr) return;

else{

Release(bt->lchild); //释放左子树

Release(bt->rchild); //释放右子树

delete bt; //释放根结点

}

}

int main( )

{

BiNode *p = nullptr;

int arr[10] = {7 ,2, 3, 10, 5, 6, 1, 8,
9, 4};

BiSortTree B{arr,10};

B.InOrder();

int key;

cout << “请输入查找的元素值”;

cin >> key;

p = B.SearchBST(key);

if (p != nullptr)

cout << p->data << endl;

else

cout << “查找失败” << endl;

system(“pause”);

return 0;

}

BiNode *BiSortTree::InsertBST(BiNode
*bt, int x)

{

if(bt == NULL) { //找到插入位置

      BiNode*s = new BiNode; 

      s->data= x;

      s->lchild= NULL;

      s->rchild= NULL;

      bt= s;

      return bt;

}

else
if (bt->data > x)

      bt->lchild= InsertBST(bt->lchild, x);

else

      bt->rchild= InsertBST(bt->rchild, x);

}

二叉排序树的删除

在二叉排序树上删除某个结点之后，仍然保持二叉排序树的特性。

分三种情况讨论：

被删除的结点是叶子；
被删除的结点只有左子树或者只有右子树；
被删除的结点既有左子树，也有右子树。

二叉排序树的删除算法——伪代码

若结点p是叶子，则直接删除结点p；

若结点p只有左子树， 则只需重接p的左子树；

若结点p只有右子树， 则只需重接p的右子树；

若结点p的左右子树均不空，则

3.1 查找结点p的右子树上的最左下结点s及s双亲结点par；

3.2 将结点s数据域替换到被删结点p的数据域；

3.3 若结点p的右孩子无左子树，

则将s的右子树接到par的右子树上；

3.4 删除结点s；

void
BiSortTree::DeleteBST(BiNode *p, BiNode *f ) {

    if (!p->lchild && !p->rchild)  {   

          if(f->child==p)        f->lchild= NULL;  

          else  f->lchild= NULL; 

          delete p;

     }

    else if (!p->rchild) {     //p只有左子树

         if(f->child==p)   f->lchild=p->lchild;

         else f->rchild=p->lchild;

                  delete p;

    }

    else if (!p->lchild) {   //p只有右子树

           if(f->child==p)  f->lchild=p->rchild;

           else f->rchild=p->rchild;

        delete p;

   
   }

else {
//左右子树均不空

         par=p;  s=p->rchild;  

         while (s->lchild!=NULL)   //查找最左下结点

         {

           par=s;

           s=s->lchild;

         }

         p->data=s->data;

         if (par==p) p->rchild=s->rchild;  //处理特殊情况

             else par->lchild=s->rchild;    //一般情况

         delete s;

       } //左右子树均不空的情况处理完毕
}

二叉排序树的查找

⑴ 若root是空树，则查找失败；

⑵ 若k＝root->data，则查找成功；否则

⑶ 若k＜root->data，则在root的左子树上查找；否则

⑷ 在root的右子树上查找。

上述过程一直持续到k被找到或者待查找的子树为空，如果待查找的子树为空，则查找失败。

二叉排序树的查找效率在于只需查找二个子树之一。

BiNode *BiSortTree::SearchBST(BiNode *root, int k)

{

if (root==NULL)

return NULL；

else if (root->data==k)

          return root;
else if (kdata)

          return SearchBST(root->lchild,k);
else

            return SearchBST(root->rchild, k);
}

平衡二叉树：或者是一棵空的二叉排序树，或者是具有下列性质的二叉排序树：

⑵ 根结点的左子树和右子树的深度最多相差1;

⑵ 根结点的左子树和右子树也都是平衡二叉树

平衡因子：结点的平衡因子是该结点的左子树的深度与右子树的深度之差。

平衡二叉树

基本思想：

在构造二叉排序树的过程中，每插入一个结点时，首先检查是否因插入而破坏了树的平衡性，

若是，

则找出最小不平衡子树，

在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。

设结点A为最小不平衡子树的根结点，对该子树进行平衡调整归纳起来有以下四种情况：

LL型

RR型

LR型

RL型

7.3.3 B－树

m阶B－树：是满足下列特性的树：

(1)
树中每个结点至多有m棵子树；

(2) 若根结点不是终端结点，则至少有两棵子树；

(3) 除根结点外，其他非终端结点至少有ém/2ù 棵子树；

(4)所有非终端结点都包含以下数据：

（n，A0，K1，A1，K2，…，Kn，An）

其中，n（ém/2ù -1≤n≤m
-1）为关键码的个数；

Ki（1≤i≤n）为关键码，且Ki＜Ki+1（1≤i≤n-1）；

Ai（0≤i≤n）为指向子树根结点的指针，且指针Ai所指子树中所有结点的关键码均小于Ki+1大于Ki。

(5)所有叶子结点都在同一层上，B树是高平衡的。

B-树的插入

基本原理：

• 当一个节点中插入新的数据时，

• 会造成节点中数据个数大于(m-1)，

• 此时需要分裂节点，

• 将节点中第[m/2]+1个数据插入到当前节点的前驱中，

• 当前节点分裂为两个节点。

删除小结： 在B-树最下层节点中删除一个关键字

当最下层结点中的关键字数大于ém/2ù -1 时，可直接删除。
当最下层待删关键字所在结点中关键字数目为最低要求ém/2ù -1时，如果其左（右）兄弟中关键字数目大于ém/2ù -1，则可采用“父子换位法”。
当最下层待删结点及其左右兄弟中的关键字数目均为最低要求数目ém/2ù -1时，需要进行合并处理，合并过程与插入时的分裂过程“互逆”，合并一次， 分支数少一，可能出现 “连锁合并”，
当合并到根时， 各分支深度同时减1。

m阶B+树的结构定义如下：

(1)每个结点至多有m个子结点；

(2)每个结点(除根外)至少有ceiling(m/2)个子结点；

(3)根结点至少有两个子结点；

(4)有k个子结点的结点必有k个关键码。

B+树的查找

查找应该到叶结点层

在上层已找到待查的关键码，并不停止

而是继续沿指针向下一直查到叶结点层的这个关键码

B+树的叶结点一般链接起来，形成一个双链表

适合顺序检索（范围检索）

特点

对于阶数相同的两棵树，每个节点所包含的分支数的定义相同（不能少于m/2,不能多于m)

每个节点所包含的关键字的个数不同

B-树中，关键字不重复出现；B+树中，叶子节点存放所有的关键字，内部结点存储着其后继节点中最大的关键字

插入操作都会引起节点的分裂

删除操作都会引起节点的合并

B-树适用于随机检索；B+树支持随机和顺序检索