新手入门之二分查找双指针题解思路（java）

目录：

1.二分查找

2.双指针

题目一：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search

public static int search(int[] nums, int target) {
        int index = -1;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                index = i;
            }
        }
        return index;
    }

题目二：

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted
 

for (int i = 0; i <numbers.length; i++) {
            int left=i+1;
            int right=numbers.length-1;
            while (left<=right){
              int another=target-numbers[i];
              //在该区间找数
                int mid=(left+right)/2;
                if (numbers[mid]==another){
                    return new int[]{i+1,mid+1};
                }
                else if (numbers[mid]>another){
                    right=mid-1;
                }
                else {
                    left=mid+1;
                }
            }
        }
        return new int[]{-1,-1};
    }

这是常规的线性查找法，但是，我们可以考虑性能更佳的二分查找，但是该方法存在一定局限性，就是其要求元素有序否则只能采用线性查找

public static int search2(int[] nums, int target) {
        int leftIndex = 0;
        int rightIndex = nums.length - 1;
        while (leftIndex<=rightIndex){
            int mid=(leftIndex+rightIndex)/2;
            if (nums[mid]==target){
                return mid;
            }
            else if (nums[mid]>target){
                rightIndex=mid-1;
            }
            else {
                leftIndex=mid+1;
            }
        }
        return -1;
    }

题目三：

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

请必须使用时间复杂度为 O(log n) 的算法。

public int searchInsert(int[] nums, int target) {
      int left=0;
            int right=nums.length-1;
            while (left<=right){
                int mid=(left+right)/2;
                if (nums[mid]==target){
                   return mid;
                }
                else if (nums[mid]<target){//在右边
                    left=mid+1;
                }
                else {
                    right=mid-1;
                }
            }
            return left;
    }

 题目四：

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

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

可以采用快慢指针的思想解决该题

就是将不是0的元素全部依次往前面移动，后面的元素全部补充0，而代码中的index就是我们所谓的慢指针，等到快指针遍历完数组之后，我们慢指针就开始补0

public int searchInsert(int[] nums, int target) {
            int left=0;
            int right=nums.length-1;
            while (left<=right){
                int mid=(left+right)/2;
                if (nums[mid]==target){
                   return mid;
                }
                else if (nums[mid]<target){//在右边
                    left=mid+1;
                }
                else {
                    right=mid-1;
                }
            }
            return left;
    }

题目五：

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-string

直接采用两个指针从左右开始遍历交换即可，如果说，题目没有明确要求不要给另外的数组分配额外的空间，我们还可以采用其他多种方法解决，例如递归，字符串倒序相加即可

public void reverseString(char[] s) {
       int left=0;
      int right=s.length-1;
      while (left<right){
          //交换位置
          char temp=s[left];
          s[left]=s[right];
          s[right]=temp;
          //左右指针
          left++;
          right--;
      }
    }

这是我第一次写博客，还请多多指点