35. Search insertion positionhttps://leetcode-cn.com/problems/search-insert-position/

Simple difficulty 1103

Given a sort array and a target value, find the target value in the array and return its index. If the target value does not exist in the array, returns the position where it will be inserted in order.

Please use a time complexity of   O(log n)   Algorithm.

Example 1:

Input: num = [1,3,5,6], target = 5
 Output: 2

Example   2:

Input: num = [1,3,5,6], target = 2
 Output: 1

Example 3:

Input: num = [1,3,5,6], target = 7
 Output: 4

Example 4:

Input: num = [1,3,5,6], target = 0
 Output: 0

Example 5:

Input: num = [1], target = 0
 Output: 0

Tips:

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums   Arranges the array in ascending order without repeating elements
• -104 <= target <= 104

AC Code:

Train of thought analysis:

This question belongs to the same type as the previous binary search   So it can still be solved in two ways   One is anterior closure and posterior closure

One is front closed and back open   The insertion position is divided into four cases

• The target value precedes all elements of the array
• The target value is equal to an element in the array
• The position where the target value is inserted into the array
• The target value follows all elements of the array

 

 

First, the code of front closing and back closing is given

​
class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        //Left closed right closed
        int left = 0;
        int right = nums.size()-1;    
        while(left<=right){
            int mid = (left+right)/2;
            if(nums[mid]>target){
                right = mid-1;
            }
            else if(nums[mid]<target){
                left = mid+1;
            }
            else{
                return mid;
            }
        }
            return right+1;
    }
};

​

The front ones are all classic dichotomy   If this value is not found   Description exclude the case where the target value is equal to an element in the array, that is, the corresponding index cannot be found in the original array   The other three cases   It should return to the positions inserted in sequence

If one is at the front   When left=right = 0   If you still enter the while loop, right will change to - 1   Therefore, the subscript it returns should be (right+1), that is, the subscript 0

Second, if you insert a position in the array   My abstract thinking ability is not so good   I simulated it twice on paper

 

 

Word ugliness   Just spray

  three   If after all elements of the array

right will always keep its position   That is, the position of the last element   So if you want to insert   right+1

 

Front closing and rear opening

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0;
        int right = n; // Define the target in the left closed right open interval, [left, right) target
        while (left < right) { // Because when left == right, the space in [left, right) is invalid
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target is in the left interval, in [left, middle]
            } else if (nums[middle] < target) {
                left = middle + 1; // target is in the right interval, in [middle+1, right)
            } else { // nums[middle] == target
                return middle; // When the target value is found in the array, the subscript is returned directly
            }
        }
        // Deal with the following four situations respectively
        // Target value before all elements of array [0,0)
        // The target value is equal to an element in the array return middle
        // Insert the target value into the position [left, right] in the array and return right
        // If the target value is after all the elements of the array [left, right], return right
        return right;
    }
};

The first few lines of code are classic ideas of dichotomy   There's nothing to say   Just look at the last return   right

Four cases

First kind   The target element precedes all elements   Right will eventually become 0   So return right directly

Second   The target element is at an element position   Just return mid directly

Third   The target element is between two elements   Draw in the same way   Get return   mid

Fourth   Target element after all elements   It means right will not change   So just return right directly

brute-force attack

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        for (int i = 0; i < nums.size(); i++) {
        // Deal with the following three situations respectively
        // The target value precedes all elements of the array
        // The target value is equal to an element in the array
        // The position where the target value is inserted into the array
            if (nums[i] >= target) { // Once num[i] greater than or equal to target is found, I is the result we want
                return i;
            }
        }
        // The target value is after all elements of the array
        return nums.size(); // If target is the largest or num is empty, the length of num is returned
    }
};

Summary: Brush algorithm questions  

First, judge the type   What method is used

two   Read the questions well   Distinguish the situation   Treat separately or in combination according to each case

three   If abstract thinking doesn't work   Be good at drawing