给我自己的关于算法

数组的算法
（1）二分查找法
对于有序数列才能使用二分查找法

public int binarySearch(Int[] arr,int n,int target){
    //限定左右边界,要清楚在哪个范围内进行查找
    int r=0,l=n-1;
    //只要还有可以查找的对象就应该继续循环，在判定这个条件时也是一个小的边界问题，当满足该条件时，看是否还在查找区间内
    int mid=(l+r)/2;
    if(arr[mid]==target){
        return mid;
        }
    if(target>arr[mid]){
        l=mid+1;
        }else{
        r=mid-1;
        }
        return -1;
    }
}

不断的维护最初的意义限制
为了防止溢出，int mid=l+(r-l)/2
1.明确变量的含义2.循环不变量。要维护变量的含义。3.小数据量的调试

move Zero (leetCode 283):leetcode.com

//时间复杂度O(n)
//空间复杂度O(n)，使用了辅助空间

public void moveZero(int[] nums){
    int[] temp;
    for(int i=0;i<nums.size();i++){
        if(nums[i]){
            temp.add(nums[i]);
        }
    }
    for(int i=0;i<temp.size();i++){
        nums[i]=temp[i];
    }
    for(int i=temp.size;i<nums.size;i++){
        nums[i]=0;
    }
}

优化

//时间复杂度O(n)
//空间复杂度O(1)

public void moveZero(int[] nums){
    int k=0;//nums中，[0...k)的元素均为非0
元素
//遍历第i个元素后，保证[0.。。i]中所有非0元素都按照顺序排列在[0...k)中
for(int i=0;i<nums.size();i++){ 
    if(nums[i]){
        nums[k++]=nums[i];
    }
}
//将nums剩余位置置0
for(int i=k;i<nums[i];i++){
        nums[i]=0;
    }

}

继续优化

public void moveZero(int[] nums){

    int k=0;
    //遍历到第i个元素后，保证[0..i]的所有非0
    //元素按照顺序排列在[0...k)中，同时[k...i]为0
    for(int i=0;i<nums.size();i++){
        if(nums[i]){
            if(i!=k){
            swap(nums[k++],nums[i]);
            }else{
                k++;
            }
        }
    }
}

计数排序，适用于元素个数有限的情况

public void sortColor(int[] nums){
    int[3] count={0,0,0};
    for(int i =0;i<nums.size();i++){
    if(nums[i]>=0&&nums[i]<=2)
        count[nums[i]]++;

//////////////////////////////////////////
//对于一个前闭后闭的待运算区间，最好设置起始值为-1
    int zero =-1;//nums[0...zero]==0
    int two = nums.size();//nums[two...n-1]==2
    for(int i=0;i<two; ){
        if(nums[i]==1){
            i++;
        }
        else if(nums[i]==2){
            two--;
            swap(nums[i],nums[two]);//因为这个two元素还未经处理，所以i不需要++
        }
        else{//nums[i]==0的情况
            if(nums[i]==0);
            zero++;
            swap(nums[zero],nums[i]);
            i++;
        }
    }

    }
}

给定一个有序数组和一个整数target，在寻找两个元素的索引，这两个 元素的和为这个target，索引由1开始

1.最直接的思考当然是暴力解法，将数组遍历两遍分别相加
2.但是从题干上我们可以看出有一个条件是数组有序，首先就应当想到二分查找法

for(int i=0;i<nums.size()-1;i++){   
    int mid=nums[i+1]+nums[nums.zise()];
    if(target-nums[i]>mid){
else if
}

int l=0;
int r=nums.size()-1;
while(l<r){ 
    if(nums[l]+nums[r]==target){
        int[2] res={l+1,r+1};
        return res;
    }
    else if(nums[l]+nums[r]<target){
        l++;
    }
    else(nums[l]+nums[r]>target){
        r--;
    }throw invalid_argument;
}