LeetCode（88、167、169、209、240、905）

LeetCode88：

思路：1、已知数组1有效m，数组2元素n。将数组2元素放入数组1，然后打印，所有元素从小到大排序。

           2、即数组1的有效元素变成m+n。数组1角标有m个，数组2角标有n个，数组第一个角标为0。

           3、定义index1=m-1；index2=n-1；index3=m+n-1；对数组1和数组2从后往前比，谁的值大谁赋给index角标在数组1中的值。

程序如下：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int index1=m-1;              //数组1，最后一个角标值
        int index2=n-1;              //数组2，最后一个角标值
        int index3=m+n-1;            //合并数组，最后一个角标值
        while(index1>=0&&index2>=0){ //判断两个数组是否存在元素
            if(nums1[index1]>nums2[index2]){     //对比最后一个元素谁大
                nums1[index3--]=nums1[index1--]; 
              //nums1大，将值赋给合并数组最后一项，然后角标自减1
            }else{
                nums1[index3--]=nums2[index2--];
              //nums2大，将值赋给合并数组最后一项，然后角标自减1
            }
        }
        if(index2>=0){//判断，如果数组1的值传完后，数组2还是否有剩余
            for(int i=0;i<=index2;i++){//有的话，执行，将数组2前面没赋的值直接赋给合并数组
                nums1[i]=nums2[i];
            }
        }
    }
}

LeetCode167：

思路：1、定义一个（最小角标）变量i=0，一个（最大角标）变量j=numbers.length-1。

           2、sum=nembers[i]+numbers[j]，如果sum的值小i++，sum的值大j--。

           3、i<j，找到后，将i+1，j+1返回。若运行下去，当i>j还没有结果那么返回null

 

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i=0;                     //最左边的角标
        int j=numbers.length-1;      //最右边的角标
        while(i<j){                  //当i<j才能循环
            int sum=numbers[i]+numbers[j];  //最左边的角标+最右边的角标的值赋给sum
            if(sum>target){          //如果sum大于target
                j--;                 //最右边角标减1
            }
            else if(sum<target){     //如果sum小于target
                i++;                 //最左边角标加1
            }else{
                return new int[]{i+1, j+1};//相等的话，将结果返回
            }
        }
        return null;                 //无结果的话，将null返回
    } 
}

LeetCode169：

思路：

class Solution {
    public int majorityElement(int[] nums) {
        int result=nums[0];
        int count=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]==result){
                count++;
            }else{
                count--;
                if(count==0){
                    result=nums[i];
                    count=1;
                }
            }
        }
        return result;
    }
}

LeetCode209：

思路：1、双指针，划窗机制。定义长度len初值0。两个变量分别为i，j。从左边开始往右，定义sum的初值0与数组角标j的值相                    加。若结果大于等于s，i往右一点缩短长度，若结果小于s，j往右移动扩大数值。直到数组最右。

           2、长度为j-i+1，注意，得对输入的判断，若相加的数小于s，则返回0。可能输入[1,2]，[0]。

 

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int len=0;   //定义初始长度
        int sum=0;   //定义初始总和为0
        int i=0;     //定义移动数i，sum取值大的时候用
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];    //相加数，和s做比较
            while(sum>=s){   //若sum大于s，则开始循环
                len=len==0?j-i+1:Math.min(j-i+1,len);//对长度len的值进行判断
                sum=sum-nums[i];//sum大于s，i向右移动，减去当前的值
                i++;            //向右移动
            }
        }
        return len;             //将长度返回
    }
}

LeetCode240：

 思路：1、先对数组判断是否为空数组，或者该数组长度为0，由于是二维数组，同样要判断行列的长度是否为0，为0的话，返回false。

            2、拿一个角落的值，比如左下角的值，由于数组是大小排序的，当该值比target小的时候，往右边移动，当该值比target大的时候，往上边移动。当i<0或者j>长度-1的时候返回false。找到的话返回true。

class LC240{
    public boolean searchMatrix(int[][] matrix, int target) {
        //                     []                  [[]]
        if(matrix==null||matrix.length==0||matrix[0].length==0){//判断该数组是否有值
            return false;                //返回false
        }
        int row=matrix.length;           //取左下角的行标
        int col=matrix[0].length;        //取右下角的列标
        int i=row-1;                     //数组中从0开始，则行标长度-1
        int j=0;                         //左下角开始，则列当前为0
        while(true){                     //开启循环
            if(target<matrix[i][j]){     //当该数大于target时，上移
                i--;                     //上移
            }else if(target>matrix[i][j]){ //当该数小于target时
                j++;                     //右移
            }else{
                return true;             //相等则返回true
            }
            if(i<0||j>=col){             //角标超出长度范围时结束
                return false;            //返回false
            } 
        }
    }
}

LeetCode905：

思路：1、从数组第一个开始，对2取余，若为0，则当前不变，i++，用Scount++记录偶数的次数。。

           2、若对2取余不为0，则为奇数，将该值与末尾的第一个数互换，记录Dcount++偶数次数。i当前要减去1，对换的数进行余数判断。

           3、当Scount+Dcount时程序结束，将A返回。

       

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A.length>1){
            int Scount=0;  //记录奇数的初值
            int Dcount=0;  //记录偶数的初值
            for(int i=0;i<A.length;i++){  //从左开始对数值进行奇偶判断
                if(A[i]%2!=0){            //不为0，则为奇数
                   int temp=A[i];         //与最后的数不断往前互换
                   A[i]=A[A.length-Dcount-1];
                   A[A.length-Dcount-1]=temp;
                   Scount++;              //记录偶数+1
                   i-=1;
                }else{
                   Dcount++;               //记录奇数+1
                 }
                if((Scount+Dcount)==A.length){  //如果奇偶满足数组长度
                   break;                 //跳出当前循环
                }
            }
        }
        return A;                         //将A数组返回
    }
}