ARTS (1)

来不及解释啦 赶紧上车~

**Algorithm**

Binary search

目标 Target    ————  要找的值
索引 Index     ————   要查找的当前位置
左右指示符 left,right—————— 用来维持查找空间的指标
中间指示符 Mid———————— 用来确定向左还是向右查找的索引

```
int binarySearch(vector<int>&nums,int target)
{
if(nums.size()==0)
return -1;
int left=0,right=nums.size()=1;
//Prevent (left+right) overflow
int mid=left+(right-left)/2;
if(nums[mid]==target){return mid;}
else if(nums[mid]<target){left =mid+1;}
else{right=mid-1;}
}
//End Condition:left>right
return -1;
}
```
This template can find elements or conditions that can be determined by accessing a single index in an array.

1.The search criteria can be determined without comparing the two sides of the element

2.There is no need for postprocessing, because each step, you are checking to see if the element is found. If you reach the end, you know that the element is not found.

 

Initial conditions:

left =0,right=length-1;

end:

left>right;

find left:

right=mid-1;

find right

left=mid+1;

```
int binarySearch2(vector<int>&nums,int target)
{
if(nums.size()==0)
return -1;
int left=0,right=nums.size();
while(left<right)
{
//Prevent (left+right) overflow
int mid=left+(right-left)/2;
if(nums[mid]==target) {return mid;}
else if(nums[mid]<target){left=mid+1;}
else{right=mid;}
}
//Post-processing;
//End Condition :left=right
if(left!=nums.size()&&nums[left]==target]  return left;)
return -1;
}
```
It's more advanced templates.For find condition and element that require access to the current index and its direct **right** neighbor index in the array.

Key Properties

1.It's find condition is taht require access to the element's direct right neighbor.

2.Use the right neighbor of the element to determine if the condition is met and decide whether to go left or right.

3. Make sure the lookup space has at least two elements in each step.

 

Initial conditions:

left=0,right=lenth

end:

left=right

find left:

right=mid

find right

left=mid+1

It Used to search for elements or conditions that require access to the current index and its directly left and right neighbor indexes in the array.

int binarySearch(vector<int>&nums,int target)
{
    if(nums.size()==0)
    return -1;
    
    int left=0,right=nums.size()-1;
    while(left+1<right){
    //Prevent (left+right) overflow
    int mid=left+(right-left)/2;
    if(nums[mid]==target)
    {
       return mid;
    }else if(nums[mid]<target){
        left=mid;    
    }else{
        right=mid;
    }


//End condition:left+1==right
if(nums[left]==target) return left;
if(nums[right]==target) return right;
return -1;
}

Key Properties

1. The search conditions require access to the element's direct left and right neighbors

2.Use the neighbor of the element to determine whether it is to the right or to the left.

3.Ensure that the lookup space has at least 3 elements in each step

4.Post-processing is required. When two elements are left, the loop / recursion ends. Need to assess whether the remaining elements are eligible.

Initial conditions:

left=0,right=length-1;

end:

left+1=right

find left:

mid=right

find right

mid=left

**Key Properties**
**Review**
**Tip**
**Share**