刷题笔记

刷题笔记

• java 运算符优先级&& ，||
  优先级（&&）>优先级(||),&&运算优先于||
• java String trim()
  trim（）：删除首位空格，会生成新的字符，会占用O（n）的空间复杂度
• java List to int[]

ans.stream().mapToInt(Integer::valueOf).toArray();

• java char[] to String

public static void main(String args[])
   {
      // Method 1: Using String object
      char[] ch = {'g', 'o', 'o', 'd', ' ', 'm', 'o', 'r', 'n', 'i', 'n', 'g'};
      String str = new String(ch);
      System.out.println(str);
 
      // Method 2: Using valueOf method
      String str2 = String.valueOf(ch);
      System.out.println(str2);
   }

• java 返回值要进行初始化
  例如：

public int func(){
    //直接int a;会出错,应该写int a=xxx;
    int a=0;
    return a;
}

• 利用双指针法解决积水体积问题的题，例如
  

• 差分数组的应用
  在仅包含 0 和 1 的数组 A 中，一次 K 位翻转包括选择一个长度为 K 的（连续）子数组，同时将子数组中的每个 0 更改为 1，而每个 1 更改为 0。
  返回所需的 K 位翻转的最小次数，以便数组没有值为 0 的元素。如果不可能，返回 -1。
  示例 1：
  输入：A = [0,1,0], K = 1
  输出：2
  解释：先翻转 A[0]，然后翻转 A[2]。

class Solution {
    public int minKBitFlips(int[] A, int K) {
        int len=A.length;
        int ans=0;
        int curRev=0;
        //差分数组，负值为所要统计的那段数组后面那个数组，所以空间需要开到len+1;
        int[] diff=new int[len+1];
        for(int i=0;i<len;i++){
            //这里是>=,不要写错成>
            if(i-1>=0)curRev+=diff[i-1];
            if((A[i]+curRev+diff[i])%2==0){
                if(i+K>len)return -1;
                ++ans;
                // ++curRev;
                diff[i]++;
                diff[i+K]--;
            }
        }
        return ans;
    }
}

• 反转list操作可调用Collections内部的函数reverse();

//反转list
Collections.reverse(lists);

• addAll（）
  addAll方法添加目标对象中的所有元素到本对象，目标对象元素改变后对本对象的元素不影响
• Arrays.sort()
  对自定义的类用sort

//按类中的val升序排序，实际上是重写了comparator
Arrays.sort(edges, (o1, o2) -> o1.val - o2.val);
//与下述相同
Arrays.sort(edges,new Comparator<edge>(){
            @Override
            public int compare(edge o1, edge o2){
                return o1.val - o2.val;
            }
        });

• 定义一个自定义的类数组后，每个元素的初始值都为null，使用的时候还需为每个元素new 一个类对象

edge[] edges=new edge[];//仅此一句的话，edges里面都是null，不能直接使用edges[i].val,会报错

• List 转 int[]

int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();

• map 遍历

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
 
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
 
}

• 子数组
  子数组是原始数组连续的子区间
• 子序列
  在数学中，某个序列的子序列是从最初序列通过去除某些元素但不破坏余下元素的相对位置（在前或在后）而形成的新序列。其元素在原数组中不一定连续
• 子串
  一个字符串 s 被称作另一个字符串S 的子串，表示 s 在 S 中出现了。子串在原序列中连续
• java 值传递
  将数组传递给其他方法时，实际上会复制对该数组的引用。
• 通过该引用对数组内容所做的任何更改都将影响原始数组。
• 但是，将引用更改为指向新数组不会更改原始方法中的现有引用。

public class Test {
    public void func(int[] arr){
        int[] b={1,2};
        arr=b;//can not change arr
        //change arr;
        arr[0]=b[0];
        arr[1]=b[1];
        System.out.println(arr[0]);
        System.out.println(arr[1]);
    }
    public static void main(String[] args) {
        int[] arr={4,5};
        Test test = new Test();
        test.func(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
    }
}

• Java Double 浮点数 比较大小 & 相等比较
  double为双精度的浮点数类型，在计算机内部用指数形式表示，可以利用设置阈值的方法比较。

public class DoubleComparer {
    private static final double DEFAULT_DELTA = 0.000001; //默认比较精度
 
    //比较2个double值是否相等（默认精度）
    public static boolean considerEqual(double v1, double v2) {
        return considerEqual(v1, v2, DEFAULT_DELTA);
    }
 
    //比较2个double值是否相等（指定精度）
    public static boolean considerEqual(double v1, double v2, double delta) {
        return Double.compare(v1, v2) == 0 || considerZero(v1 - v2, delta);
    }
 
    //判断指定double是否为0（默认精度）
    public static boolean considerZero(double value) {
        return considerZero(value, DEFAULT_DELTA);
    }
 
    //判断指定double是否为0（指定精度）
    public static boolean considerZero(double value, double delta) {
        return Math.abs(value) <= delta;
    }
}

• 拿到关于图的题

  • 确定其是否连通

  • java 中可以用二维数组表示点之间的连接情况，且每一个graph[i]的长度不一定要一样，例如int[][] grid={{0,0},{1,1,0},{1}}；也是合法的；

  • 人和座位用 0 到 2N-1 的整数表示，情侣们按顺序编号，第一对是 (0, 1)，第二对是 (2, 3)，以此类推，最后一对是 (2N-2, 2N-1)。从已知情侣的编号找他的另一半可以巧用异或：int b=a^1; 其中，a和b为情侣关系。

  • 不要被lc hard的tag吓到了

  • 输入参数中有矩阵，对无效输入用例进行过滤

  // except matrix=null or matrix='[]' or matrix='[[]]';
  if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
          return false;
  }