第七章 查找

第七章 查找

7.1概述

1.列表：由同一类型的数据元素组成的集合。

关键码：数据元素中的某个数据项，可以标识列表中的一个或一组数据元素。

键值：关键码的值。

主关键码：可以唯一地标识一个记录的关键码。

次关键码：不能唯一地标识一个记录的关键码。

2.查找 ：在具有相同类型的记录构成的集合中找出满足给定条件的记录。

静态查找 ：不涉及插入和删除操作的查找 。

动态查找 ：涉及插入和删除操作的查找。

3. 线性表：适用于静态查找，主要采用顺序查找技术、折半查找技术。

树表：适用于动态查找，主要采用二叉排序树的查找技术。

散列表：静态查找和动态查找均适用，主要采用散列技术。

7.2线性表的查找技术

1.顺序查找

#include

using namespace std;

const int MaxSize = 100;

class LineSearch{

public:

    LineSearch(int a[ ], int n); //构造函数

   ~LineSearch( ) { } //析构函数为空

    int SeqSearch(int k); //顺序查找

private:

    int data[MaxSize]; //查找集合为整型

    int length; //查找集合的元素个数

};

LineSearch :: LineSearch(int a[ ], int n){

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

        data[i+1] = a[i]; //查找集合从下标1开始存放

    length = n;

}

int LineSearch :: SeqSearch(int k)

{  

     i=n;

     while (i>0 && data[i]!=k)

         i--;

     return i;

}

带监视哨的折半查找：将哨兵放在查找方向的尽头处，

免去了在查找过程中每一次比较后都要判断查找位置是否越界，从而提高查找速度。

 

int LineSearch :: SeqSearch(int k)

{

    int i = length;        //从数组高端开始比较

    data[0] = k;           //设置哨兵

    while (data[i] != k) //不用判断下标i是否越界

        i--;

    return i;

}

单链表的顺序查找

int LinkSearch::SeqSearch2(Node *first, int k){ 

         Node *p;

         int count=0;//记录比较的次数

         p=first->next;

         int j=1;//记录数据在表中的位置

      while (p &&  p->data != k)

         {p=p->next;     j++;    count++;}

         if (!p){

             cout<<“查找失败，比较的次数为:"<<count<<endl;    

             return 0;

     } else{

             cout<<“\n”<<“查找成功，比较的次数为:"<<count<<endl;     

          return j;

         }

}

2.折半查找

非递归折半查找

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]相对应的折半查找判定树。

7.3树表的查找技术

1.二叉排序树

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

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

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

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

注意：中序遍历二叉排序树可以得到一个按关键码有序的序列

#include <iostream>

using namespace std;

template <class DataType>

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 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;

}

2.平衡二叉树

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

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

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

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

最小不平衡子树：在平衡二叉树的构造过程中，以距离插入结点最近的、且平衡因子的绝对值大于1的结点为根的子树。

在一个平衡二叉排序树上插入一个新结点S时，主要包括以下三步：

     （1） 查找应插位置， 同时记录离插入位置最近的可能失衡结点A（A的平衡因子不等于0）。

      （2） 插入新结点S， 并修改从A到S路径上各结点的平衡因子。

      （3） 根据A、 B的平衡因子， 判断是否失衡以及失衡类型， 并做相应处理。

7.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树是高平衡的。

7.4散列表的查找技术

散列函数的构造：直接定址法 、除留余数法、数字分析法、平方取中法、折叠法（分段叠加法）

冲突处理方法：开放定址法、、链地址法、建立公共溢出区

散列函数的构造

1.直接定址法：散列函数是关键码的线性函数，即：H(key) = a ´ key + b  （a，b为常数）

2.保留余数法：散列函数为：H(key)=key  mod  p

3.数字分析法：根据关键码在各个位上的分布情况，选取分布比较均匀的若干位组成散列地址。

4.平方取中法：对关键码平方后，按散列表大小，取中间的若干位作为散列地址（平方后截取）。

5.折叠法：将关键码从左到右分割成位数相等的几部分，将这几部分叠加求和，取后几位作为散列地址。

冲突处理方法

1.闭散列方法

（1）线性探测法：当发生冲突时，从冲突位置的下一个位置起，依次寻找空的散列地址。

对于键值key，设H(key)=d，闭散列表的长度为m，则发生冲突时，寻找下一个散列地址的公式为：

      Hi=(H(key)＋di) % m   （di=1，2，…，m-1）

 

int HashSearch1(int ht[ ], int m, int k)

{

     j=H(k); 

     if (ht[j]==k) return j;   //没有发生冲突，比较一次查找成功

     i=(j+1) % m;

     while (ht[i]!=Empty && i!=j) 

     {

         if (ht[i]==k) return i;  //发生冲突，比较若干次查找成功

         i=(i+1) % m;    //向后探测一个位置

     }

     if (i==j) throw "溢出";

     else ht[i]=k;   //查找不成功时插入

}

（2）二次探测法

当发生冲突时，寻找下一个散列地址的公式为：

                     Hi=(H(key)＋di)% m

（di=12，－12，22，－22，…，q2，－q2且q≤m/2）

 

（3）随机探测法

当发生冲突时，下一个散列地址的位移量是一个随机数列，即寻找下一个散列地址的公式为：

                         Hi=(H(key)+di)% m   

（di是一个随机数列，i=1，2，……，m-1）

 

2.开散列法

（1）拉链法

基本思想：将所有散列地址相同的记录，即所有同义词的记录存储在一个单链表中（称为同义词子表），在散列表中存储的是所有同义词子表的头指针。

Node<int> *HashSearch2(Node<int> *ht[ ], int m, int k)

{    

     j=H(k);

     p=ht[j];

     while (p && p->data!=k)

           p=p->next;

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

     else {

         q=new Node<int>; q->data=k;

         q->next= ht[j];

         ht[j]=q; 

     }

}

3.建立公共溢出区

基本思想：

散列表包含基本表和溢出表两部分（通常溢出表和基本表的大小相同），

将发生冲突的记录存储在溢出表中。

查找时，对给定值通过散列函数计算散列地址，先与基本表的相应单元进行比较，若相等，则查找成功；否则，再到溢出表中进行顺序查找。