数据结构：查找

查找

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

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

键值：关键码的值。

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

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

查找的基本概念

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

查找的结果 ：若在查找集合中找到了与给定值相匹配的记录，则称查找成功；否则，称查找失败。

 

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

静态查找适用于：查找集合一经生成，便只对其进行查找，而不进行插入和删除操作; 或经过一段时间的查找之后，集中地进行插入和删除等修改操作；

 

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

动态查找适用于：查找与插入和删除操作在同一个阶段进行，例如当查找成功时，要删除查找到的记录，当查找不成功时，要插入被查找的记录。

 

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

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

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

 

平均查找长度：将查找算法进行的关键码的比较次数的数学期望值定义为平均查找长度。计算公式为： ASL=从1到n的pi*ci的求和

n：问题规模，查找集合中的记录个数；

pi：查找第i个记录的概率；

ci：查找第i个记录所需的关键码的比较次数。

 

 

顺序查找 （线性查找）

 

#include

using namespace std;

 

const int MaxSize = 100;

class LineSearch{

public:

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

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

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

    int BinSearch1(int k); //折半非递归查找

    int BinSearch2(int low, int high, 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;

}

}

 

 

顺序查找的优点：

算法简单而且使用面广。

对表中记录的存储结构没有任何要求，顺序存储和链接存储均可；

对表中记录的有序性也没有要求，无论记录是否按关键码有序均可。

 

顺序查找的缺点：

平均查找长度较大，特别是当待查找集合中元素较多时，查找效率较低。

 

折半查找

适用条件：

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

必须采用顺序存储。

 

基本思想：

在有序表中（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

}

 

折半查找判定树

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

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

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

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

 

判定树的构造方法

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

⑵ 当n＞0时，

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

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

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

 

判定树的特点

任意两棵折半查找判定树，若它们的结点个数相同，则它们的结构完全相同

具有n个结点的折半查找树的高度为log2N+1

 

判定树的性质

任意结点的左右子树中结点个数最多相差1

任意结点的左右子树的高度最多相差1

任意两个叶子所处的层次最多相差1

 

二叉排序树（Binary Search Tree）

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

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

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

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

 

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

 

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

 

}

 

二叉排序树的构造算法

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）操作：以其后继（右子树中的最小值）替代之，然后再删除该前驱结点。

 

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;

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

 }

 

二叉排序树的查找

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

}

平衡二叉树：

 

     平衡二叉树：或者是一棵空的二叉排序树，

 

         或者是具有下列性质的二叉排序树： ⑴ 根结点的左子树和右子树的深度最多相差1;

 

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

 

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

 

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

 

   基本思想： 在构造二叉排序树的过程中，每插入一个结点时，首先检查是否因插入而破坏了树的平衡性， 若是，     则找出最小不平衡子树，     在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。

 

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

 

1. LL型

B=A->lchild；

A->lchild=B->rchild；  

B->rchild=A；A->bf=0；   

B->bf=0；

if  (FA==NULL)   

root=B;  else  

if  (A==FA->lchild)    

FA->lchild=B;

else  FA->rchild=B；

 

2. RR型  

B=A->rchild；

A->rchild=B->lchild；

B->lchild=A；

A->bf=0；   

B->bf=0；

if  (FA==NULL)   

root=B; 

else  if(A==FA->lchild)   

FA->lchild=B;          

else   FA->rchild=B；

 

3. LR型

 

B=A->lchild；

C=B->rchild；  

B->rchild=C->lchild；  

A->lchild=C->rchild；  

C->lchild=B；    

C->rchild=A；if (S->key <C->key)     /* 在C-L下插入S  */   

{ A->bf=-1；  B->bf=0 ；  C->bf=0； }

if (S->key >C->key)     /* 在C-R下插入S  */    

{ A->bf=0；  B->bf=1 ；  C->bf=0； }

if (S->key ==C->key)    /* C本身就是插入的新结点S */   

{ A->bf=0；  B->bf=0 ；C->bf=0 }    

if  (FA==NULL)  root=C;    

else  if (A==FA->lchild)   FA->lchild=C;    

else  FA->rchild=C；    

 

4. RL型

 

B=A->rchild；    

C=B->lchild；  

B->lchild=C->rchild；  

A->rchild=C->lchild；  

C->lchild=A；  

C->rchild=B；          然后针对上述三种不同情况，修改A、B、C的平衡因子：

if (S->key <C->key)     /* 在CL下插入S  */    

{ A->bf=0；  B->bf=-1 ；  C->bf=0； }

if (S->key >C->key)     /* 在CR下插入S  */    

{ A->bf=1；  B->bf=0 ；  C->bf=0； }

if (S->key ==C->key)    /* C本身就是插入的新结点S */    

{ A->bf=0；  B->bf=0 ；C->bf=0 }        

最后，将调整后的二叉树的根结点C“接到”原A处。 令A原来的父指针为FA，如果FA非空，则用C代替A做FA的左子或右子；否则，原来A就是根结点，此时应令根指针t指向C：                         if  (FA==NULL)   root=C;         

else  if  (A==FA->lchild)   FA->lchild=C;         

else  FA->rchild=C；  

 

 

 

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

 

插入：

 

基本原理： 当一个节点中插入新的数据时，会造成节点中数据个数大于(m-1)，此时需要分裂节点，将节点中第[m/2]+1个数据插入到当前节点的前驱中，当前节点分裂为两个节点。

 

删除：

当最下层结点中的关键字数大于ém/2ù -1 时，可直接删除。

当最下层待删关键字所在结点中关键字数目为最低要求ém/2ù -1时，如果其左（右）兄弟中关键字数目大于ém/2ù -1，则可采用“父子换位法”。

当最下层待删结点及其左右兄弟中的关键字数目均为最低要求数目ém/2ù -1时，需要进行合并处理，合并过程与插入时的分裂过程“互逆”，合并一次， 分支数少一，可能出现 “连锁合并”， 当合并到根时， 各分支深度同时减1。

B+树

B+树是B-树的变体，也是一种多路搜索树：

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

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

 

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

 

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

 

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

 

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

 

⑴ 含有m个关键码，每一个关键码对应一棵子树。

 

⑵ 关键码Ki是它所对应的子树的根结点中的最大（或最小）关键码。

 

⑶ 所有终端结点中包含了全部关键码信息，以及指向关键码记录的指针。

 

⑷ 所有终端结点按关键码的大小链在一起，形成单链表，并设置头指针。

 

散列表的查找技术：

 

  散列的基本思想：在记录的存储地址和它的关键码之间建立一个确定的对应关系。这样，不经过比较，一次读取就能得到所查元素的查找方法。

 

 散列表：采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表。

 

散列函数：将关键码映射为散列表中适当存储位置的函数。

 

散列地址：由散列函数所得的存储位置址 。  

 

冲突：对于两个不同关键码ki≠kj，有H(ki)＝H(kj)，即两个不同的记录需要存放在同一个存储位置,ki和kj相对于H称做同义词。

 

设计散列函数一般应遵循以下原则：

 

⑴ 计算简单。散列函数不应该有很大的计算量，否则会降低查找效率。

 

⑵ 函数值即散列地址分布均匀。函数值要尽量均匀散布在地址空间，这样才能保证存储空间的有效利用并减少冲突。

 

散列函数是关键码的线性函数，即：H(key) = a ´ key + b  （a，b为常数）

 

散列函数——除留余数法：H(key)=key  mod  p

 

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

 

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

 

处理冲突的方法——开放定址法：由关键码得到的散列地址一旦产生了冲突，就去寻找下一个空的散列地址，并将记录存入。

 

在线性探测法构造的散列表中查找算法

 

 

 

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;   //查找不成功时插入

}

 

处理冲突的方法——拉链法（链地址法）

 

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

 

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;       

}

}

 

处理冲突的方法——公共溢出区

 

 基本思想： 散列表包含基本表和溢出表两部分（通常溢出表和基本表的大小相同）， 将发生冲突的记录存储在溢出表中。 查找时，对给定值通过散列函数计算散列地址，先与基本表的相应单元进行比较，若相等，则查找成功；否则，再到溢出表中进行顺序查找。

散列查找的性能分析

   由于冲突的存在，产生冲突后的查找仍然是给定值与关键码进行比较的过程。

在查找过程中，关键码的比较次数取决于产生冲突的概率。而影响冲突产生的因素有：

（1）散列函数是否均匀

（2）处理冲突的方法

（3）散列表的装载因子

     α=表中填入的记录数/表的长度