查找与排序——查找

查找

基本概念

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

查找算法的性能

查找算法时间性能通过关键码的比较次数来度量。
关键码的比较次数与以下因素有关
⑴算法；
⑵问题规模；
⑶待查关键码在查找集合中的位置；
⑷查找频率。
查找频率与算法无关，取决于具体应用。
通常假设pi是已知的。
查找算法的时间复杂度是问题规模n和待查关键码在查找集合中的位置k的函数，记为T(n，k)。

查找方式

顺序查找
普通的顺序查找方法
带监视哨的顺序查找方法
折半查找
折半查找的判定树

#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; //查找集合的元素个数
};

顺序查找

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

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
}

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

判定树特点

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

判定树性质

任意结点的左右子树中结点个数最多相差1
任意结点的左右子树的高度最多相差1
任意两个叶子所处的层次最多相差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;
}

平衡二叉树

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

散列表查找

散列的基本思想：
在记录的存储地址和它的关键码之间建立一个确定的对应关系。这样，不经过比较，一次读取就能得到所查元素的查找方法。
散列表：
采用散列技术将记录存储在一块连续的存储空间中，这块连续的存储空间称为散列表。
散列函数：
将关键码映射为散列表中适当存储位置的函数。
散列地址：
由散列函数所得的存储位置址 。
散列只是通过记录的关键码定位该记录，没有完整地表达记录之间的逻辑关系，所以，散列主要是面向查找的存储结构。
散列查找的限制：
散列技术一般不适用于允许多个记录有同样关键码的情况。
有冲突，降低了查找效率，体现不出计算式查找的优点
散列方法也不适用于范围查找
不能查找最大值、最小值
也不可能找到在某一范围内的记录。
散列技术的关键问题：
⑴ 散列函数的设计。如何设计一个简单、均匀、存储利用率高的散列函数。
⑵ 冲突的处理。如何采取合适的处理冲突方法来解决冲突。
冲突：
对于两个不同关键码ki≠kj，有H(ki)＝H(kj)，即两个不同的记录需要存放在同一个存储位置,ki和kj相对于H称做同义词。
设计散列函数一般应遵循以下原则：
⑴ 计算简单。散列函数不应该有很大的计算量，否则会降低查找效率。
⑵ 函数值即散列地址分布均匀。函数值要尽量均匀散布在地址空间，这样才能保证存储空间的有效利用并减少冲突。
H(key) = a * key + b （a，b为常数）
一般情况下，选p为小于或等于表长（最好接近表长）的最小素数
根据关键码在各个位上的分布情况，选取分布比较均匀的若干位组成散列地址。
对关键码平方后，按散列表大小，取中间的若干位作为散列地址（平方后截取）。
将关键码从左到右分割成位数相等的几部分，将这几部分叠加求和，取后几位作为散列地址。

冲突处理

开散列方法( open hashing，也称为拉链法，separate chaining ，链地址法)
闭散列方法( closed hashing，也称为开地址方法，open addressing ，开放定址法)
建立公共溢出区
基本思想：
散列表包含基本表和溢出表两部分（通常溢出表和基本表的大小相同），
将发生冲突的记录存储在溢出表中。
查找时，对给定值通过散列函数计算散列地址，先与基本表的相应单元进行比较，若相等，则查找成功；否则，再到溢出表中进行顺序查找。

散列查找性能分析

由于冲突的存在，产生冲突后的查找仍然是给定值与关键码进行比较的过程。
在查找过程中，关键码的比较次数取决于产生冲突的概率。而影响冲突产生的因素有：
（1）散列函数是否均匀
（2）处理冲突的方法
（3）散列表的装载因子
α=表中填入的记录数/表的长度