【算法与数据结构】35、LeetCode搜索插入位置

所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。

题目

一、二分法

  首先先看题目，题目给了一个有序数组和目标值，要求必须使用时间复杂度$O(logn)$的代码，那么我们可以首先想到二分法的时间复杂度就是$O(logn)$，因此这道题实际上可以分成两部分，一部分是二分法查找数组，找到的话返回索引，第二部分是找不到目标时返回目标值的插入索引。

  第一部分容易解决，就是一个普通的二分查找算法，程序中为while循环部分。第二部分就要考虑三种情况（插入值在数组前端，中间，尾端），那么我们可以利while循环得到的middle，假设有序数组为[1 3 5 6]

情况	target	middle	nums[middle]	left	right
前端	0	0	1	0	-1
中间	2	0	1	1	0
中间	4	1	3	2	1
尾端	7	3	6	4	3

  可以看出来，当$nums[middle]>target$时，直接返回middle，就是所在插值索引，当$nums[middle]<targe$时，返回middle + 1就是所在插值索引。同理可以得，return left / return right + 1也是结果。
程序如下：

    // 二分法
	int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int middle = 0;
        while (left <= right) {
            middle = (right + left) / 2;
            if (nums[middle] < target) {
                left = middle + 1;
            }
            else if (nums[middle] > target) {
                right = middle - 1;
            }
            else {
                return middle;
            }
        }
        // 方法一
        //if (nums[middle] > target) {
        //    return middle;
        //}
        //else {
        //    return middle + 1;
        //}
         方法二
        //return left;
        // 方法三
        return right + 1;
	}

复杂度分析：

• 时间复杂度： $O(logn)$，二分法查找的查找速度是$lo{g}_{2}n$，可以去掉底数（乘上一个常数），结果就是$O(logn)$。
• 空间复杂度：$O(1)$， 开辟的内存空间大小是一个常量。

二、暴力穷解法

  查找数组内的目标数值，那用暴力穷解法必定可以做，直接的想法就是写一个for循环，遍历整个数组，一直循环到找到为止，找不到且到数组尾端就返回-1。甚至可以用库函数几行搞定这个遍历过程。

    // 暴力穷举法
    int searchInsert2(vector<int>& nums, int target) {
        for (int i = 0; i < nums.size(); i++){
            if (nums[i] >= target) {
                return i;
            }
        }
        return nums.size();
    }

复杂度分析：

• 时间复杂度： $O(n)$，最坏的情况下是每个数都要遍历一遍。
• 空间复杂度：$O(1)$， 开辟的内存空间大小是一个常量。

完整代码

// LeetCode 35、搜索插入位置
# include <iostream>
# include <vector>
using namespace std;

class Solution {
public:
    // 暴力穷举法
    int searchInsert2(vector<int>& nums, int target) {
        for (int i = 0; i < nums.size(); i++){
            if (nums[i] >= target) {
                return i;
            }
        }
        return nums.size();
    }

    // 二分法
	int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int middle = 0;
        while (left <= right) {
            middle = (right + left) / 2;
            if (nums[middle] < target) {
                left = middle + 1;
            }
            else if (nums[middle] > target) {
                right = middle - 1;
            }
            else {
                return middle;
            }
        }
        // 方法一
        //if (nums[middle] > target) {
        //    return middle;
        //}
        //else {
        //    return middle + 1;
        //}
         方法二
        //return left;
        // 方法三
        return right + 1;
	}
};


void my_print(vector <int>& v, string msg)
{
    cout << msg << endl;
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << "  ";
    }
    cout << endl;
}

int main()
{
    int target = 0;
    int arr[] = { 1,3,5,6 };
    vector<int> nums;
    Solution s1;
    for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
    {
        nums.push_back(arr[i]);
    }
    my_print(nums, "目标数组：");
    int index = s1.searchInsert(nums, target);
    cout << index << endl;
	system("pause");
	return 0;
}

end