leetcode java一些小语法

1、数据结构

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

2、acm处理输入输出

读一个整数： int n = sc.nextInt();
读一个字符串：String s = sc.next();
读一个浮点数：double t = sc.nextDouble();
读一整行： String s = sc.nextLine();
判断是否有下一个输入可以用sc.hasNext()或sc.hasNextInt()或sc.hasNextDouble()或sc.hasNextLine()

while(sc.hasNext()) {
            List<Integer> res = new ArrayList<>();
            int m = sc.nextInt();
            int n = sc.nextInt();
        }

①输入一个int

import java.util.Scanner;

public class cin {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 输入单个int
        int i = sc.nextInt();
        System.out.println("读取到的数字是：" + i);
        // 输入多个int
    }
}

②接收字符串

nextLine 可以接收空格或者 tab 键，其输入以 enter 键结束。
next 不会接收回车符，tab 或者空格键，遇到空格就算结束

public class cin {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();//读取的字符串数量
        int index = 0;
        String[] array = new String [i];//存放读取的字符串
        while(index < i) {
            array[index++] = sc.next();
        }
        for (String str : array) {//输出读取的字符串
            System.out.println("输入的字符串：" + str);
        }
    }
}

nextLine：会吞掉 ” 2 ” 后面那个 enter 作为第一个字符串，可以接收空格
2
h e l l o
输入的字符串：
输入的字符串：h e l l o

next ：以空格或者enter为结尾
2
h l
输入的字符串：h
输入的字符串：l

③输入数组

法一：输入字符串，用逗号隔开
注意空格不合法

public class cin {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.next().toString();
        String[] arr  = str.split(",");
        int[] b = new int[arr.length];
        for(int j = 0; j<b.length;j++) {
            b[j] = Integer.parseInt(arr[j]);
            System.out.print(b[j]+" ");
        }
    }
}

法二：提前规定个数

public class cin {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] b=new int[3];
        for(int i=0;i<b.length;i++){
            b[i]=in.nextInt();
        }
    }
}

④二维数组

二维数字数组

import java.util.Scanner;

public class Test{
    public static void main(String ars[]){
        Scanner s=new Scanner(System.in);
        int x=s.nextInt();
        int y=s.nextInt();
        int [][]array=new int[x][y];//初始化数组
        for(int i=0;i<x;i++)//循环输入
            for(int j=0;j<y;j++)
                array[i][j]=s.nextInt();
    }
}

格式：
2 2
1 2
3 4

二维字符数组

import java.util.Scanner;

public class Test{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt(); //n行
        int m = scan.nextInt();//m列
        String[]  temp= new String[n+1]; //字符串数组做中间变量
        for(int i = 0; i< n; i++) {
            temp[i] = scan.next();
        }

        char[][] p = new char[n][m];   // temp字符串数组转为二维数组p[n][m];
        for(int i = 0; i<n; i++) {
            for(int j = 0; j< m; j++) {
                p[i][j] = temp[i].charAt(j);
                System.out.println(p[i][j]);
            }
        }
    }
}

格式：
2
3
abc
abd

⑤一些数据结构

树：

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

链表：

public class ListNode {
    int val;
    ListNode next;
    ListNode() {}
    ListNode(int val) { this.val = val; }
    ListNode(int val, ListNode next) { 
    	this.val = val; 
    	this.next = next; 
    }
}

⑥一些小工具

求最大公约数（辗转相除）

public static int gcd(int a,int b){
        if(a<b){//保证a>b
            int t=a;
            a=b;
            b=t;
        }
        while(b>0){
            int temp=a%b;
            a=b;
            b=temp;
        }
        return a;
    }

3、ArrayList

初始化：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("o1", "o2"));

包含：

boolean exist=list.contains(a)

Arryay转数组：

list.stream().mapToInt(Integer::intValue).toArray();

数组初始化填充：

Arrays.fill(res, -1);

找最大值：

Arrays.stream(dp).max().getAsInt();

①动态数组

[ [1,2,3] , [4,5,6] ]
List<List<Integer>> res = new ArrayList<>();
res.add(Arrays.asList(nums[i],nums[left],nums[right]))

②arraylist里存数组

List<int[]> res = new ArrayList<>();
获取最后一个数：res.get(res.size()-1)[1]
转换为数组：res.toArray(new int[res.size()][2])

int[] array=(int[])a.toArray(new int[size]);//会报错
Integer[] array = list.toArray(new Integer[list.size()]);//能正确运行
//int[]并不等同于Integer[]

数组里存arraylist：List<Integer>[] adj=new ArrayList[size];

③动态字符串

List<StringBuilder>res = new ArrayList<>();
res.get(row).append(c);
组合成string：

StringBuilder res_s = new StringBuilder();
for (StringBuilder r : res){
    res_s.append(r);
} 
return res_s.toString();

④复制与排序

int[] numsSorted = new int[nums.length];
System.arraycopy(nums, 0, numsSorted, 0, nums.length);
Arrays.sort(numsSorted);

⑤回溯中

正常来说，为避免res里添加path被改变，python里应该是"".join(path) 或res.append(path[:]，对应Java里res.add(path.toString())，此时Java中path可以作为全局变量声明。

如果java里使用res.add(path)，那path在后续可能被改变，不能声明全局变量，只能在add的时候复制一份放进res里，或者放在dfs函数的参数里传递。

保险的的办法是把path放在dfs的参数中传递，
如果把path设成全局变量

List<List<Integer>> res=new ArrayList<>();
List<Integer>path=new ArrayList<>();

则添加到res时，必须复制一份再添加，否则会被之后的更改，类似python的res.append(path[:])而不是res.append(path)

if(target==0) {
    res.add(new ArrayList<>(path));
    return;
}

⑥其他

如果想在List<String>res=new ArrayList<>();中存储数字转换成的字符，只能存Integer num，不能int num,使用res.add(num.toString();

4、排序

①数组或String：Arrays.sort(nums); 默认升序
降序：Arrays.sort(nums, Collections.reverseOrder());

部分排序，左闭右开：Arrays.sort(arr,1,4);

②优先队列，默认从大到小

PriorityQueue<Integer> queue= new PriorityQueue<>();
queue.poll();//从末尾移除最小的
queue.peek()//顶峰最大值

③复杂排序

二维数组按左端点排序（升序）：
Arrays.sort(intervals, (int[] l1, int[] l2) -> (l1[0] - l2[0]));

二维ArrayList按左端点排序（升序）：
Collections.sort(list, (o1, o2) -> o1[0] - o2[0])

//先按长度排序，长的在前面，长度一样按字典序排，字典序小的在前面
Collections.sort(dictionary, (a,b)->{
            if (a.length() != b.length()) return b.length() - a.length();
            return a.compareTo(b);
        });

5、长度

数组int[] nums : int len = nums.length;
arraylist / hashmap / stack / stringbuilder : list.size();
字符串String s : s.length()

6、String

切片：res=res.substring(0,res.length()-1);左闭右开
s1是否以s2开头：s1.startsWith(s2)
s1是否包含s2：s1.indexOf(s2)

转换为数组：char[] arr = s.toCharArray();
遍历string：for (char c : s.toCharArray())

int转string：String s=String.valueOf(x); String s=Integer.toString(n);
string转数字 ：Integer.valueOf(c)
string 转数字减一，再转char：c=(Integer.parseInt(c) - 1) + "";
（Integer.valueOf(“”)返回的是一个Integer对象，而Integer.parseInt(“”)返回的是一个基本类型的int）

string比较字典序：t.compareTo(res) < 0 t比res小

数组 int[] a 转string(重新拷贝)：String.copyValueOf(a)

7、StringBuilder

StringBuilder res = new StringBuilder();
StringBuilder res=new StringBuilder(s);
添加：res.append();(里面可以是数字或字符串)
插入：res.Insert(0, "aaa: ");指定位置前
sb.setCharAt(0,"a")指定位置处
删除一段：delete(int startIndex,int endIndex)删除 [ 起始 , 结尾 ）
删除某个：path.deleteCharAt(path.length()-1)
反转/转成String：res.reverse().toString();
比较：res.equals(s);
charAt(i)

dfs(String s)
调用：dfs("")
回溯的时候可以直接：dfs(s+"a")

8、hashmap

map.containsKey("zhang")
map.remove("zhang")
map.put("zhang", "31");
map.get("zhang")==null
map.isEmpty()
遍历key：for (String key : map.keySet())
遍历值：for (String values : map.values())
遍历全部：

for (Entry<String, String> entry : map.entrySet()) {
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + "," + value);
		}

注意：Map<Character,Integer>存入后，顺序式随机的，如果要保证顺序，可以用linkedhashmap

9、优先队列/堆

大根堆

PriorityQueue<Integer> heap =
                new PriorityQueue<>((n1, n2) -> n1 - n2);
                
heap.offer();//加入元素
heap.peek();//堆顶元素（最大值）
heap.poll();//移除堆顶元素

//二维数组，先按第一位从大到小，相同时再按第二位从大到小
PriorityQueue<int[]>pq=new PriorityQueue<int[]>(
(int[]pair1,int[]pair2) ->
pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair1[1]
);

// 升序队列、 降序队列
PriorityQueue<Integer> asc = new PriorityQueue<>();
PriorityQueue<Integer> desc = new PriorityQueue<>((a, b) -> b - a);

10、其他

字符形式的数字转换为数字：Integer.valueOf('1')=49，s.charAt(i)-'0'
数字转英文字母：(char)(i+'a')（i 是相对‘a’的偏移量，int）

十进制转进制：Integer.toString(int par1,int par2)，par1表示要转成字符串的数字，par2表示要转成的进制表示

次方：Math.pow(-2,31)

最大最小值：int max = Integer.MIN_VALUE; int min = Integer.MAX_VALUE;

数组最大值：Arrays.stream(arr).max().getAsInt();

数组求和：Arrays.stream(nums).sum();

数组切片：int[] b = Arrays.copyOfRange(a, 0, idx);

随机数：

Random r=new Random();
if(r.nextInt(count)==0)//[0,count)