数据结构_第七章_查找

第七章 查找

7.1查找的基本概念
7.2线性表的查找技术
7.3树表的查找技术
7.4散列表的查找技术

7.1查找的基本概念

查找的基本概念
列表：由同一类型的数据元素组成的集合。
关键码：数据元素中的某个数据项，可以标识列表中的一个或一组数据元素。
键值：关键码的值。
主关键码：可以唯一地标识一个记录的关键码。
次关键码：不能唯一地标识一个记录的关键码。
查找 ：在具有相同类型的记录构成的集合中找出满足给定条件的记录。
查找的结果 ：若在查找集合中找到了与给定值相匹配的记录，则称查找成功；否则，称查找失败。
静态查找 ：不涉及插入和删除操作的查找 。
动态查找 ：涉及插入和删除操作的查找。
静态查找适用于：查找集合一经生成，便只对其进行查找，而不进行插入和删除操作; 或经过一段时间的查找之后，集中地进行插入和删除等修改操作；
动态查找适用于：查找与插入和删除操作在同一个阶段进行，例如当查找成功时，要删除查找到的记录，当查找不成功时，要插入被查找的记录。
查找结构 ：面向查找操作的数据结构 ，即查找基于的数据结构。

7.2线性表的查找技术

顺序查找 （线性查找）
基本思想：
从线性表的一端向另一端逐个将关键码与给定值进行比较，
若相等，则查找成功，给出该记录在表中的位置；
若整个表检测完仍未找到与给定值相等的关键码，则查找失败，给出失败信息
单链表的顺序查找

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

折半查找——非递归算法

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个结点的折半查找判定树的深度为(log2n)+1
查找成功：在表中查找任一记录的过程，即是折半查找判定树中从根结点到该记录结点的路径，和给定值的比较次数等于该记录结点在树中的层数。
查找不成功：查找失败的过程就是走了一条从根结点到外部结点的路径，和给定值进行的关键码的比较次数等于该路径上内部结点的个数（失败情况下的平均查找长度等于树的高度）。

7.3 树表的查找技术

二叉排序树
二叉排序树（也称二叉查找树）：或者是一棵空的二叉树，或者是具有下列性质的二叉树：
⑴若它的左子树不空，则左子树上所有结点的值均小于根结点的值；
⑵若它的右子树不空，则右子树上所有结点的值均大于根结点的值；
⑶ 它的左右子树也都是二叉排序树。
二叉排序树的插入算法
若二叉排序树为空树，则新插入的结点为新的根结点；
否则，如果插入的值比根节点值大，则在右子树中进行插入；否则，在左子树中进行插入。
递归。
二叉排序树的插入算法

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

二叉排序树的构造算法

BiSortTree::BiSortTree(int a[ ], int n)
{
 root = NULL;
 for (int i = 0; i < n; i++)
  root = InsertBST(root, a[i]);
}

二叉排序树的删除
分三种情况讨论：
1.被删除的结点是叶子。
2.被删除的结点只有左子树或者只有右子树。
3.被删除的结点既有左子树，也有右子树。
情况1——被删除的结点是叶子结点。
操作：将双亲结点中相应指针域的值改为空。
情况2——被删除的结点只有左子树或者只有右子树。
操作：将双亲结点的相应指针域的值指向被删除结点的左子树（或右子树）。
情况3——被删除的结点既有左子树也有右子树。
操作：以其前驱（左子树中的最大值）替代之，然后再删除该前驱结点。
操作：以其后继（右子树中的最小值）替代之，然后再删除该前驱结点。

void BiSortTree::DeleteBST(BiNode<int> *p, BiNode<int> *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;
           } //左右子树均不空的情况处理完毕
 }

二叉排序树的查找
在二叉排序树中查找给定值k的过程是：
⑴ 若root是空树，则查找失败；
⑵ 若k＝root->data，则查找成功；否则
⑶ 若k＜root->data，则在root的左子树上查找；否则
⑷ 在root的右子树上查找。
上述过程一直持续到k被找到或者待查找的子树为空，如果待查找的子树为空，则查找失败。
二叉排序树的查找效率在于只需查找二个子树之一

BiNode *BiSortTree::SearchBST(BiNode<int> *root, int k)
{
    if (root==NULL)
    return NULL；
    else if (root->data==k) 
              return root;
    else if (k<root->data) 
              return SearchBST(root->lchild, k);
    else 
          return SearchBST(root->rchild, k);
}

平衡二叉树（AVL树）
平衡二叉树：或者是一棵空的二叉排序树，或者是具有下列性质的二叉排序树：
⑴ 根结点的左子树和右子树的深度最多相差1;
⑵ 根结点的左子树和右子树也都是平衡二叉树。
平衡因子：结点的平衡因子是该结点的左子树的深度与右子树的深度之差。
最小不平衡子树：在平衡二叉树的构造过程中，以距离插入结点最近的、且平衡因子的绝对值大于1的结点为根的子树。
基本思想：
在构造二叉排序树的过程中，每插入一个结点时，首先检查是否因插入而破坏了树的平衡性,若是，则找出最小不平衡子树，在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。
设结点A为最小不平衡子树的根结点，对该子树进行平衡调整归纳起来有以下四种情况：

1. LL型
2. RR型
3. LR型
4. RL型
   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-树中删除一个关键字-非最下层节点中删除
   基本原则：在保持有序性、平衡性的前提下，进行操作。

7.4 散列表（hash）的查找技术

散列的基本思想：在记录的存储地址和它的关键码之间建立一个确定的对应关系。这样，不经过比较，一次读取就能得到所查元素的查找方法。
散列表：采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表。
散列函数：将关键码映射为散列表中适当存储位置的函数。
散列地址：由散列函数所得的存储位置址 。
冲突：对于两个不同关键码ki≠kj，有H(ki)＝H(kj)，即两个不同的记录需要存放在同一个存储位置,ki和kj相对于H称做同义词。
散列函数——直接定址法
散列函数是关键码的线性函数，即：
H(key) = a  key + b （a，b为常数）
散列函数——除留余数法
散列函数为
H(key)=key mod p
一般情况下，选p为小于或等于表长（最好接近表长）的最小素数
散列函数——数字分析法
根据关键码在各个位上的分布情况，选取分布比较均匀的若干位组成散列地址。
散列函数——平方取中法
对关键码平方后，按散列表大小，取中间的若干位作为散列地址（平方后截取）。
散列函数——折叠法
将关键码从左到右分割成位数相等的几部分，将这几部分叠加求和，取后几位作为散列地址。
冲突的处理
开散列方法( open hashing，也称为拉链法，separate chaining ，链地址法)
闭散列方法( closed hashing，也称为开地址方法，open addressing ，开放定址法)
建立公共溢出区
处理冲突的方法——开放定址法
线性探测法
当发生冲突时，从冲突位置的下一个位置起，依次寻找空的散列地址。
对于键值key，设H(key)=d，闭散列表的长度为m，则发生冲突时，寻找下一个散列地址的公式为：
Hi=(H(key)＋di) % m （di=1，2，…，m-1）
堆积：在处理冲突的过程中出现的非同义词之间对同一个散列地址争夺的现象。
二次探测法
当发生冲突时，寻找下一个散列地址的公式为：
Hi=(H(key)＋di)% m
（di=12，－12，22，－22，…，q2，－q2且q≤m/2）
随机探测法
当发生冲突时，下一个散列地址的位移量是一个随机数列，即寻找下一个散列地址的公式为：
Hi=(H(key)+di)% m
（di是一个随机数列，i=1，2，……，m-1）
处理冲突的方法——拉链法（链地址法）
基本思想：将所有散列地址相同的记录，即所有同义词的记录存储在一个单链表中（称为同义词子表），在散列表中存储的是所有同义词子表的头指针
设n个记录存储在长度为m的散列表中，则同义词子表的平均长度为n / m。
处理冲突的方法——公共溢出区
基本思想：
散列表包含基本表和溢出表两部分（通常溢出表和基本表的大小相同），
将发生冲突的记录存储在溢出表中。
查找时，对给定值通过散列函数计算散列地址，先与基本表的相应单元进行比较，若相等，则查找成功；否则，再到溢出表中进行顺序查找。