LeetCode打卡——查找算法（2）

@(Aaron) [LeetCode, C++]

主要内容包括：

• 查找算法

• 实例讲解

---

1、查找算法简介

本文承接上文查找算法（1）继续介绍查找算法相关内容。

1.1 插值查找

在介绍插值查找之前，首先考虑一个新问题，为什么上述算法一定要是折半，而不是折四分之一或者折更多呢？

打个比方，在英文字典里面查“apple”，你下意识翻开字典是翻前面的书页还是后面的书页呢？如果再让你查“zoo”，你又怎么查？很显然，这里你绝对不会是从中间开始查起，而是有一定目的的往前或往后翻。

同样的，比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5， 我们自然会考虑从数组下标较小的开始查找。

经过以上分析，折半查找这种查找方式，不是自适应的（也就是说是傻瓜式的）。二分查找中查找点计算如下：

$mid=(low+high)/2,即mid=low+1/2\ast (high-low);$

通过类比，我们可以将查找的点改进为如下：

$mid=low+(key-a[low])/(a[high]-a[low])\ast (high-low)，$

也就是将上述的比例参数1/2改进为自适应的，根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。

**基本思想：**基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。

注：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。

复杂度分析：查找成功或者失败的时间复杂度均为O(log2(log2n))。

1.2 二叉查找树

二叉查找树定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

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

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

  3) 左、右子树也分别为二叉排序树；

  4) 没有键值相等的节点。

二叉查找树的性质：对二叉查找树进行中序遍历，即可得到有序的数列。

二叉查找树的时间复杂度： 它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡（比如，我们查找上图（b）中的“93”，我们需要进行n次查找操作）。我们追求的是在最坏的情况下仍然有较好的时间复杂度，这就是平衡查找树设计的初衷。

二叉查找树的高度决定了二叉查找树的查找效率。

二叉查找树的插入过程如下：
  1) 若当前的二叉查找树为空，则插入的元素为根节点;

  2) 若插入的元素值小于根节点值，则将元素插入到左子树中;

  3) 若插入的元素值不小于根节点值，则将元素插入到右子树中。

例题： 判断一个二叉树是否为二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(root == nullptr) return true;
       
        stack<TreeNode *> S;
        TreeNode *p = root;
        long long val1 = LONG_MIN, val2 = LONG_MIN + 1;
        
        while(!S.empty() || p)
        {
            if (p)
            {
                S.push(p);
                p = p->left;
                
            }
            else
            {
                
                p = S.top();
                val2 = p->val;
                S.pop();
                p = p->right;
                if(val1 >= val2) return false;
                val1 = val2;
            }
        }
        return true;
    }
};

2.3 分块查找

分块查找又称索引顺序查找，它是顺序查找的一种改进方法。

算法思想： 将n个数据元素"按块有序"划分为m块（m ≤ n）。每一块中的结点不必有序，但块与块之间必须"按块有序"；即第1块中任一元素的关键字都必须小于第2块中任一元素的关键字；而第2块中任一元素又都必须小于第3块中的任一元素，……

算法流程：

  step1 先选取各块中的最大关键字构成一个索引表；

  step2 查找分两个部分：先对索引表进行二分查找或顺序查找，以确定待查记录在哪一块中；然后，在已确定的块中用顺序法进行查找。

2 实例讲解

2.1 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法一：暴力法

暴力法很简单，遍历每个元素 xx，并查找是否存在一个值与 target - xtarget−x 相等的目标元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    
        for(int i = 0; i < nums.size(); i++)
        {
            int diff = target - nums[i];
            for(int j = i + 1; j < nums.size(); j++)
            {
                if(diff == nums[j]) return {i, j};
            }
        }
        return {};
    }
};

复杂度分析：

时间复杂度： $O(n^2)$

对于每个元素，我们试图通过遍历数组的其余部分来寻找它所对应的目标元素，这将耗费 O(n)O(n) 的时间。因此时间复杂度为 $O(n^2)$。

空间复杂度： $O(1)$。

解法二： 一遍哈希表

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashmap;
        for(int i = 0; i < nums.size(); i++)
        {
            int diff = target - nums[i];
            if(hashmap.find(diff) != hashmap.end()) return {hashmap[diff], i};
            hashmap[nums[i]] = i;
        }
        return {};
    }
};

复杂度分析：

时间复杂度： $O(n)$，
我们只遍历了包含有 n 个元素的列表一次。在表中进行的每次查找只花费 $O(1)$ 的时间。

空间复杂度： $O(n)$，
所需的额外空间取决于哈希表中存储的元素数量，该表最多需要存储 n 个元素。

2.2 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

其实这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码，而且是用哈希法 在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是$O(n^2)$，也是可以在leetcode上通过，但是程序的执行时间依然比较长 。

拿这个nums数组来举例，首先将数组排序，然后 有一层for循环，i从下表0的地方开始，同时定一个下表left 定义在i+1的位置上，定义下表right 在数组结尾的位置上。

我们依然还是在数组中找到 abc 使得 $a+b+c=0$，我们这里相当于 $a=nums[i]$ $b=nums[left]$ $c=nums[right]$。

接下来我们如何移动left 和right呢， 如果$nums[i]+nums[left]+nums[right]>0$ 就说明 此时三数之和大了，因为数组是排序后了，所以right下表就应该想左移动，这样才能让三数之和小一些。

如果 $nums[i]+nums[left]+nums[right]<0$ 说明 此时 三数之和小了， left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

时间复杂度：O(n^2)

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int n = nums.size();
        sort(nums.begin(), nums.end());
        vector<vector<int>> ans;
        // 枚举 a
        for (int first = 0; first < n; ++first) {
            // 需要和上一次枚举的数不相同
            if (first > 0 && nums[first] == nums[first - 1]) {
                continue;
            }
            // c 对应的指针初始指向数组的最右端
            int third = n - 1;
            int target = -nums[first];
            // 枚举 b
            for (int second = first + 1; second < n; ++second) {
                // 需要和上一次枚举的数不相同
                if (second > first + 1 && nums[second] == nums[second - 1]) {
                    continue;
                }
                // 需要保证 b 的指针在 c 的指针的左侧
                while (second < third && nums[second] + nums[third] > target) {
                    --third;
                }
                // 如果指针重合，随着 b 后续的增加
                // 就不会有满足 a+b+c=0 并且 b<c 的 c 了，可以退出循环
                if (second == third) {
                    break;
                }
                if (nums[second] + nums[third] == target) {
                    ans.push_back({nums[first], nums[second], nums[third]});
                }
            }
        }
        return ans;
    }
};