力扣刷题记录

简单

1. 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

思路：因为数组是升序的，所以要解决挺简单。用二分查找（设定开始与结束边界），在每一次二分查找无结果后，徐改变相应的边界再次二分查找，一直比较到开始边界与结束边界相等。

代码：

class Solution {
    public int search(int[] nums, int target) {
        int begin = 0;
        int end = nums.length-1;
        while(begin<=end){
            int mid = (end-begin)/2+begin;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid]>target){
                end = mid-1;
            }else{
                begin = mid+1;
            }
        }
        return -1;
    }
}

2. 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

思路：数组是排序数组，基本思路和上题一样

代码：

class Solution {
    public int searchInsert(int[] nums, int target) {
        int begin = 0;
        int end = nums.length-1;
        while(begin <= end){
            int mid = (end - begin)/2 + begin;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                begin = mid+1;
            }else{
                end = mid-1;
            }
        }
        return begin;
    }
}

3. 给定一个整数数组，判断是否存在重复元素。如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

思路：先将数组排序，然后循环遍历查看数组中是否有相邻的元素相同的情况

代码：

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for(int i=0;i<nums.length-1;i++){   
            if(nums[i]==nums[i+1]){
                return true;
            }
        }
        return false;
    }
}

4.给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

思路一：创建新数组，长度和nums一样，然后循环遍历，平方赋值，再排序

代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int []news = new int[nums.length];
        for(int i=0;i<nums.length;i++){
            news[i] = nums[i]*nums[i];
        }
        Arrays.sort(news);
        return news;
    }
}

思路二：因为题中显示数组是非递减顺序，所以我们可以判断元素值与0的关系找到原数组负数与非负数的分界线i
所以平方后可以看成两个新数组，i之前的数组递减，i之后的数组递增。再通过循环比较前者数组末位的数值在后者数组的索引位置，在相应位置填写。

代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int n = nums.length;
        int flag= -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                flag= i;
            } else {
                break;
            }
        }

        int[] ans = new int[n];
        int index = 0, i = flag, j = flag+ 1;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans[index] = nums[j] * nums[j];
                ++j;
            } else if (j == n) {
                ans[index] = nums[i] * nums[i];
                --i;
            } else if (nums[i] * nums[i] < nums[j] * nums[j]) {
                ans[index] = nums[i] * nums[i];
                --i;
            } else {
                ans[index] = nums[j] * nums[j];
                ++j;
            }
            ++index;
        }

        return ans;
    }
}

5. 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

思路：先从索引0开始循环，查看元素值那个为0，得到其索引i；然后再次内循环从数组末尾开始，如果元素值不为0的话，将其与外循环得到的为0索引互换值。

class Solution {
    public void moveZeroes(int[] nums) {
        int n = 0;
        for(int i=0;i<nums.length;i++){
           if(nums[i]==0){
               for(int j=nums.length-1;j>i;j--){
                   if(nums[j]!=0){
                    n = nums[i];
                    nums[i] = nums[j];
                    nums[j] = n;
                   }
               }
           }
        }
    }
}

6. 给定一个已按照 非递减顺序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。
   函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 1 开始计数 ，所以答案数组应当满足 1 <= answer[0] < answer[1] <= numbers.length 。

思路：遍历，第二个数字只能在第一个数字右边，所以从i+1开始

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int []res = new int[2];
        for(int i=0;i<numbers.length;i++){
            for(int j=i+1;j<numbers.length;j++){
                if((numbers[i]+anumbers[j])==target){
                    res[0] = i+1;
                    res[1] = j+1;
                }
            }
        }
      return res;
    }
}

官方思路：在数组中找到两个数，使得它们的和等于目标值，可以首先固定第一个数，然后寻找第二个数，第二个数等于目标值减去第一个数的差。利用数组的有序性质，可以通过二分查找的方法寻找第二个数。为了避免重复寻找，在寻找第二个数时，只在第一个数的右侧寻找。

官方代码：

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for (int i = 0; i < numbers.length; ++i) {
            int low = i + 1, high = numbers.length - 1;
            while (low <= high) {
                int mid = (high - low) / 2 + low;
                if (numbers[mid] == target - numbers[i]) {
                    return new int[]{i + 1, mid + 1};
                } else if (numbers[mid] > target - numbers[i]) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
        }
        return new int[]{-1, -1};
    }
}

7. 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
   不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

思路：由题可知，反转后坐标完全对称。所以设置双指针。一个指向左端索引0，一个指向末端n-1.当两个指针索引相同时，循环结束。

代码：

class Solution {
    public void reverseString(char[] s) {
        int i = s.length;
        for(int left=0,right=(i-1);left<right;left++,right--){
            char a = s[left];
            s[left] = s[right];
            s[right] = a;
        }
    }
}