力扣Day2

28、实现 strStr()

 给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

根据示例以及提交编译记录发现：该题目的意思是：判断haystack是否含有needle，如果存在，就返回第一次needle在haystack出现的位置，如果没有，则返回-1【原本以为只要在haystack里找到needle的第一个字符就行】

法一：暴力匹配

//法一 暴力匹配
class Solution {
    public int strStr(String haystack, String needle) {
        return haystack.indexOf(needle);
 
    }
}

int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

法二：KMP算法：KMP 是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法

                                                                 （KMP算法思路图解摘自JAVA尚硅谷数据结构和算法）

部分匹配表的规则：

"A"的前缀和后缀都为空集，共有元素的长度为0；

"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

• //法二:KMP算法
  class Solution {
      public int strStr(String str1, String str2) {
          if(str2.length()==0) {//特例规定
              return 0;
          }
         //创建一个 next 数组保存部分匹配值
         //next数组的意义是：获取到一个字符串(str2子串) 的部分匹配值表
          int[] next = new int[str2.length()];
          for (int i = 1, j = 0; i < str2.length(); i++) {
          //当 str2.charAt(i) != str2.charAt(j),我们需要从next[j-1]获取新的j(就是从j的前一位数组获取新的j)
          //直到我们发现有str2.charAt(i) == str2.charAt(j)成立才退出
              while (j > 0 && str2.charAt(i) != str2.charAt(j)) {
                  j = next[j - 1];//这是kmp算法的核心点
              }
              //当 str2.charAt(i) == str2.charAt(j) 满足时，部分匹配值就是+1
              if (str2.charAt(i) == str2.charAt(j)) {
                  j++;
              }
              next[i] = j;
          }
          //遍历 i是str1的索引，j是str2的索引
          for (int i = 0, j = 0; i < str1.length(); i++) {
          //需要处理str1.charAt(i) ！= str2.charAt(j),去调整j的大小
          //KMP 算法核心点, 可以验证...
              while (j > 0 && str1.charAt(i) != str2.charAt(j)) {
                  j = next[j - 1];
              }
              if(str1.charAt(i) == str2.charAt(j)) {
                  j++;
              }
              if(j == str2.length()) {//找到了
                  return i - j + 1;
                  //加1是因为是如果满足相等，则j++,之后再for循环的i++,但是当j++后到达j == str2.length()
                  //就直接return了,就没有继续的for循环的i++,所以这里要+1
              }
          }
          return -1;
      }
  }
  

• 35、搜索插入位置

  给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法

• 

//法一 通过拷贝数组来进行数组扩容
class Solution {
    public int searchInsert(int[] nums, int target) {
        int[] arr = new int[nums.length + 1];//数组扩容，容量比原数组大1，防止找不到数组就添加
        for (int i = 0; i < nums.length; i++) {
            arr[i] = nums[i];//拷贝数组
            if (nums[i] == target) {
                return i;
            }
        }
        arr[arr.length - 1] = target;//没有找到数，则添加进去
        Arrays.sort(arr);//从小到大排序
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return 0;
    }
}

//法二 动态数组
class Solution {
    public int searchInsert(int[] nums, int target) {
        List<Integer>list=new ArrayList<>();
        for(int i:nums){
            list.add(i);
        }
        if(list.contains(target)){
            return list.indexOf(target);//查找第一次出现target的索引值
        }else{
            list.add(target);
            Collections.sort(list);//排序
            return list.indexOf(target);
        }
    }
}

list.get(int index)； //通过索引值获取动态数组中的元素

法三：二分查找：

题意是叫你在排序数组中寻找是否存在一个目标值，那么训练有素的读者肯定立马就能想到利用二分法，但这题还多了个额外的条件，即如果不存在数组中的时候需要返回按顺序插入的位置，那我们还能用二分法么？答案是可以的，我们只需要稍作修改即可。

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left=0,right=nums.length-1;
        while(left<=right){
            int mid=left+(right-left)/2;
            if(nums[mid]==target){
                return mid;
            }else if(nums[mid]<target){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        return left;//没有找到target，那么插入的位置就是在left这里
    }
}

53、最大子数和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组 是数组中的一个连续部分。

贪心算法

class Solution {
    public int maxSubArray(int[] nums) {
        int sum = 0;
        res = nums[0];//设置当前的元素为nums[0],因为若数组只有一位元素肯定返回一位元素的值
        for (int x : nums) {
            sum = Math.max(sum + x, x);//每次都加一位当前元素x与当前元素x比较大小
            res = Math.max(res, sum);//把数值大的返回给res
        }
        return res;
    }
}