C++实现常用查找算法

在日常编程和面试中，查找算法和排序算法需要非常熟练。本文用C++语言的语法来写常用的查找算法：顺序查找，二分查找，

一、顺序查找

1.1基本思想（有序无序皆可以）

1 从表中的第一个元素开始，依次与关键字比较。
2 若某个元素匹配关键字，则查找成功。
3 若查找到最后一个元素还未匹配关键字，则查找失败。

1.2 时空复杂度

1.查找成功时的平均查找长度为:(假设每个数据元素的概率相等）
ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;
2.当查找不成功时，需要n+1次比较，时间复杂度为O(n);所以，顺序查找的时间复杂度为O(n)。
3. 查找成功时的平均查找长度为:(假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;当查找不成功时，需要n+1次比较，时间复杂度为O(n);
4. 所以，顺序查找的时间复杂度为O(n)。

1.3 算法优缺点

优点：对于待查的结构无任何要求，算法简单；当待查表中的记录个数较少时，采用顺序查找较好，顺序查找既可用于顺序结构存储，又使用于链接结构存储。
缺点：时间复杂度较大，数据规模较大时效率较低。

1.4 C++实现

template <typename T>
//在长度为n的数组a中查找目标常量值x
int sequentialSearch(T a[],int n const T& x)
{
    int i;
    for(i=0;i<n;i++)
    {
        if(a[i]==x)
        {
            return i;
        }
    }
    return -1;
}

二、二分查找（折半查找）

2.1基本思想（针对有序）

1.查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；
2. 如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
3. 如果在某一步骤数组为空，则代表找不到。 这种搜索算法每一次比较都使搜索范围缩小一半。

2.2时空复杂度

最坏情况下，目标值比较次数为log2(n+1)，且期望（平均）时间复杂度为O(log2n)；

2.3算法优缺点

优点：查找迅速，每次可以使得搜索范围减少一半；
缺点：必须先排序，为有序数组才行。

2.4C++实现

template <typename T>
//在起点为start，终点为end的有序数组arr中搜索目标值hkey
int binarySearch(T arr[],int start,int end,int hkey)
{
    if(start>end)
        return -1;
    int mid=start+(end-start)/2;
    if(arr[mid]>hkey)
    {
        return binarySearch(arr,start,mid-1,hkey);
    }
    else if(arr[mid]<hkey)
    {
        return binarySearch(arr,mid+1,end,hkey);
    }
    else
    {
        return mid;
    }
}

三、分块查找

3.1算法思想

将n个数据元素”按块有序”划分为m块（m ≤ n）。每一块中的结点不必有序，但块与块之间必须”按块有序”；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；而第2块中任一元素又都必须小于第3块中的任一元素
步骤如下:
1.首先将查找表分成若干块，在每一块中数据元素的存放是任意的，但块与块之间必须是有序的；
2.建立一个索引表，把每块中最大的关键字值按块的顺序存放在一个辅助数组中，这个索引表也按升序排列；
3.查找时先用给定的关键字值在索引表中查找，确定满足条件的数据元素存放在哪个块中，查找方法既可以是折半方法，也可以是顺序查找。
4.再到相应的块中顺序查找，便可以得到查找的结果。

3.2C++实现

//在序列数组st中，用分块方法查找target的记录，在arr[]中二分查找，确定属于m个块的那哪一个块中
int blockSearch(int arr[],int st[],int target,int m)
{
    int start=0;
    int end=arr.size()-1;
    int index=binarySearch(arr,start,end,target);
    if(index>=0)
    {
        int j=index>0?m*index:index;
        int length=(index+1)*m;
        //在确定的快中用顺序查找方法查找key
        for(int k=j;k<length;k++)
        {
            if(target==st[k])
            {//查找成功
                return k;
            }
        }
    }
}

四、二叉树查找

4.1基本思想

二叉查找树是先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后在就行和每个节点的父节点比较大小，查找最适合的范围。 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。

二叉查找树:也叫二叉搜索树，或称二叉排序树,或者是一棵空树，或者是具有下列性质的二叉树:
1.若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
2.若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
3.任意节点的左、右子树也分别为二叉查找树；
4.没有键值相等的节点。
二叉查找树性质：对二叉查找树进行中序遍历，即可得到有序的数列。

4.2 时空复杂度

它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡。因此追求的目标是在最坏的情况下仍然有较好的时间复杂度，这就是平衡查找树设计的初衷。
基于二叉查找树进行优化，进而可以得到其他的树表查找算法，如平衡树、红黑树等高效算法。

4.3 C++实现

//定义二叉树数据结构
class TreeNode
{
pubic:
    TreeNode(int value)
    {
        this.value = value;
    }
private:
    int value;
    TreeNode left;
    TreeNode right;
}

class TreeSearch
{
	//从根节点为root的树中查找节点的值为value的节点
    TreeNode search(TreeNode root,int value)
    {   //空树
        if (root == nullptr)
        {
            return nullptr;
        }
        //定义当前节点
        TreeNode current = root;
        while(current != nullptr)
        {
            if (current.val < value)
            {
                //如果当前节点的值比value小，则从其右子树中开始找
                current = current.right;
            }
            else if (current.val > value)
            {
                //如果当前节点的值比value大，则从其左子树中开始找
                current = current.left;
            }
            else if (current.val == value)
            {
                //找到则返回这个节点
                return current;
            }
        }
        return nullptr;
    }
}

五、哈希表查找

散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。

5.1基本思想

1.用给定的哈希函数构造哈希表；
2.根据选择的冲突处理方法解决地址冲突；
常见的解决冲突的方法：拉链法和线性探测法。
3.在哈希表的基础上执行哈希查找。

5.2 时空复杂度

单纯论查找复杂度：对于无冲突的Hash表而言，查找复杂度为O(1)

5.3C++实现

//实则unordered_map数据结构就是这么实现的
int searchHash(int[] hash, int hashLength, int key)
{
    // 哈希函数
    int hashAddress = key % hashLength;
    // 指定hashAdrress对应值存在但不是关键值，则用开放寻址法解决
    while (hash[hashAddress] != 0 && hash[hashAddress] != key)
    {
        hashAddress = (++hashAddress) % hashLength;
    }
    // 查找到了开放单元，表示查找失败
    if (hash[hashAddress] == 0)
        return -1;
    return hashAddress;
}