数据结构笔记--总结各种查找算法及其应用

基于线性表的查找：具体分为顺序查找法、折半查找法以及分块查找法。三种方式都非常简单，在此引出一个概念，平均查找长度。即为了确定数据元素在列表中的位置，需和给定值进行比较的关键字个数的期望值，称为查找算法在查找成功时的平均查找长度。对于长度为n的列表，查找成功时的平均查找长度为ASL = P1C1 + P2C2 + P3C3 + … + PnCn = ∑PiCi (i=i..n) 其中Pi为查找列表中第i个元素的概率，Ci为找到列表中第i个元素时，已经进行过的关键字比较次数。那么顺序表的平均查找长度就是1/2(n+1)，折半查找的平均查找长度为((n+1)/n)log(n+1)-1，当索引使用顺序查找时的分块查找的平均查找长度为1/2(n/s+s)+1，当索引使用二分查找是的平均查找长度为log(n/s+1)+s/2。其中表的长度为n，分为b块，每块含有s个元素。

// 二分查找，返回下标
template<typename T>
int BinSearch(T *array, int len, T key)
{
int lowIndex = 0, highIndex = len - 1;
int midIndex = 0;
while (lowIndex <= highIndex)
{
midIndex = (lowIndex + highIndex) / 2;
if (key == array[midIndex])
return midIndex;
else if (key < array[midIndex])
highIndex = midIndex - 1;
else
lowIndex = midIndex + 1;
}
return -1;
}

基于树的查找：又称树表查找法，主要包括二叉排序树、平衡二叉排序树和B_树。这里主要介绍二叉排序树。

二叉排序树的插入：

1、若二叉排序树是空树，则key(待插入值)成为二叉排序树的根；

2、若二叉排序树非空，则将key与二叉排序树的根比较，如果key等于根节点的值，停止插入；

如果key小于根节点的值，则将key插入左子树；

如果key大于根节点的值，则将key插右左子树。

// 向二叉排序树中插入
void InsertBT(BitTree **root, DataType key)
{
if ((*root) == NULL)
{
*root = new BitTree();
(*root)->m_data = key;
(*root)->m_lchild = (*root)->m_rchild = NULL;
}
else
{
if (key < (*root)->m_data)
{
InsertBT(&(*root)->m_lchild, key);
}
else if (key >(*root)->m_data)
{
InsertBT(&(*root)->m_rchild, key);
}
}
}

二叉排序树的删除：

1、若p(待删除的节点)为叶子节点，则可将其直接删除。

2、若p只有左子树，或者只有右子树，则可将p的左子树或右子树直接改为p的双亲节点的左子树。

3、若p既有左子树，又有右子树，则首先找到p的左子树中最大的值，并将其值赋给p节点，然后删掉这个最大值。偷梁换柱。

// 在二叉排序树中删除
void DeleteBT(BitTree **root, DataType key)
{
BitTree *pCul = *root, *pParent = NULL;
while (pCul != NULL)
{
if (key == pCul->m_data)
{
break;
}
pParent = pCul;
if (key < pCul->m_data)
{
pCul = pCul->m_lchild;
}
else
{
pCul = pCul->m_rchild;
}
}
if (pCul == NULL)
{
return;
}
if (pCul->m_lchild == NULL)
{
if (pParent == NULL)
{
*(root) = pCul->m_rchild;
delete pCul;
pCul = NULL;
}
else
{
if (pParent->m_lchild == pCul)
{
pParent->m_lchild = pCul->m_rchild;
}
else if (pParent->m_rchild == pCul)
{
pParent->m_rchild = pCul->m_rchild;
}
}
delete pCul;
pCul = NULL;
}
else
{
BitTree *pTempCul = pCul->m_lchild, *pTempParent = pCul;
while (pTempCul->m_rchild != NULL)
{
pTempParent = pTempCul;
pTempCul = pTempCul->m_rchild;
}
pCul->m_data = pTempCul->m_data;
if (pCul == pTempParent)
{
pTempParent->m_lchild = pTempCul->m_lchild;
}
else
{
pTempParent->m_rchild = pTempCul->m_lchild;
}
delete pTempCul;
pTempCul = NULL;
}
return;
}

二叉排序树的平均查找长度为log n；

计算式查找法：哈希法

处理冲突的方法：1、开放定址法，当key的hash地址出现冲突时，以此地址为基础，在产生一个hash地址，直到不冲突为止。

2、再hash法，同时构造多个不同的hash函数，当hash地址发生冲突时，再使用另一个hash函数重新计算，并写入新表。

3、链地址法，将所有出现冲突的元素构成一个单链表。

4、建立公共溢出区，将hash表分为基本表与溢出表两部分，没发生冲突的放在基本表，否则放在溢出表。

拓展：查找一组序列中最小的K个数

将这组序列中前k个数维护成一个最大堆，然后遍历序列，将序列中的元素与最大堆的首元素进行比较，如果序列中的元素大于堆中的元素，那么他就一定大于堆中其他元素，即不是最小的k个数，丢弃。否则，交换。在STL中，set和multiset都是使用红黑树实现的，所以这两个容器可以用来模拟最大堆。multiset允许插入元素重复。

void SearchLeastNum(const vector<DataType> &array, const size_t k, multiset<DataType, greater<DataType>> &least)
{
least.clear();
if (k < 1 || array.size() < k)
{
return;
}
auto vIt = array.begin();
for (; vIt != array.end(); ++vIt)
{
// 先初始化一个包含K个元素的最大堆
if (least.size() < k)
{
least.insert(*vIt);
}
// 如果要插入的元素小于最大堆的最大值，替换
else
{
auto sIt = least.begin();
if (*vIt < *sIt)
{
least.erase(sIt);
least.insert(*vIt);
}
}
}
}