LeetCode刷题零碎知识点整理

原创已于 2025-04-07 14:48:39 修改 · 1k 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

于 2025-02-24 23:14:06 首次发布

LeetCode刷题专栏收录该内容

31 篇文章

订阅专栏

系列博客目录

文章目录

数组变量有length属性，String类的对象有length()方法。
String s; s.split("\\s+");不能去除头部空格，需要使用s = s.trim();
String类的对象有toCharArray()方法，List<>类型有toArray()方法，都需要使用对应类型的数组来接收返回值。

List<Integer> list = new ArrayList<>();
list.add(1);

// 将 List<Integer> 转换为 Integer[]
Integer[] integerArray = list.toArray(new Integer[0]);

// 将 Integer[] 转换为 int[]（基本类型数组）
int[] ret = new int[integerArray.length];
for (int i = 0; i < integerArray.length; i++) {
    ret[i] = integerArray[i]; // 将每个 Integer 转换为 int
}

String类型的变量有indexOf() 方法和 lastIndexOf()方法，参数也是个String类型的变量。
Character.isLetterOrDigit(); Character.toLowerCase();前面方法都是返回boolean值，这两个方法都是传参为一个char型的变量。
Math.min(); Math.max();注意后面方法名为小写。
Arrays.sort();传入一个数组；Arrays.equals();可以传入两个char数组类型的变量。Arrays.toString();可传入一个char数组，返回一个String类型的变量。
ArrayList()拥有add()方法。
for(char c : X) X位置可以填写一个char[] String类型的变量不可以
(map.get(chars[i]).equals(XX);注意前面map为HashMap，HashMap里面value为String类型的变量，要加括号，后面可以填入String类型的变量。还有一种判断两个字符串是否相等的方法Objects.equals(XXX, XXX);
Collections.reverse();填入参数为List<>类型，且不用接收返回值。
new ArrayList(hashMap.values());

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List<String>> ret = new HashMap();
        for(String str : strs){
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String s = Arrays.toString(chars);
            List<String> list = ret.getOrDefault(s, new ArrayList());
            list.add(str);
            ret.put(s, list);
        }
        return new ArrayList(ret.values());
    }
}

HashSet<Integer> set = new HashSet<>();有add() 和 contains()两个方法，注意与HashMap()对比。for(int num : set ) 直接用变量名字
StringBuffer buffer = new StringBuffer(Integer.toString(nums[i])); buffer.toString(); buffer.append() 可放入charAt(i)当作参数。 buffer.reverse();

				StringBuffer buffer = new StringBuffer(Integer.toString(nums[left]));
                buffer.append("->");
                buffer.append(nums[right]);append可以直接添加nums[right]，但是在初始化时，要用包装类
                ret.add(buffer.toString());

List<int[]> list; list.toArray(new int[0][]); 返回的是int[][]类型的，并且因为里面0的原因，意味着返回的数组大小不依赖原始数组的大小。

Arrays.sort(points, new Comparator<int[]>(){
            public int compare(int[] point1, int[] point2){
                if(point1[1] > point2[1]){
                    return 1;//说明需要排序
                }else if(point1[1] < point2[1]){
                    return -1;
                }else{
                    return 0;
                }
            }
        });

栈和队列都使用 Deque<XX> deque = new LinkedList(); deque.offerFirst(); deque.pollFirst(); deque.offerLast(); deque.pollLast();

				switch(str){
                    case "+" :
                        stack.offerLast( right + left);
                        break;
                    case "-" :
                        stack.offerLast( left - right);
                        break;
                    case "*" :
                        stack.offerLast( right * left);
                        break;
                    case "/" :
                        stack.offerLast( left / right);
                        break;
                    default:
                }

想要使用一个结点的属性，需要确定其一定不为null
String.join(" ", list); 这里面的list为List类型 String str; str.substring(0, i);返回的是0到i-1位置的字符串。
Arrays.copyOfRange(X, X, X); 第一位置为一个数组，后面两个为数组下标。需要接收返回值。
List<> list; list.size(); list.get(i);
int 型与’0’相加为int型 String s; s.charAt(0) 返回的是char型，s.charAt(0) - ‘0’ 得到int型。（char)(sum % 2 + ‘0’) 后面这部分要加括号。

	    for(HashMap.Entry<Integer, Integer> entry : map.entrySet()){
            int times = entry.getValue();
            int key = entry.getKey();
            if(times == 1){
                return key;
            }
        }

n >>>= 1 n无符号右移1位
位运算有时int ret 需要初始化为 0 通过 int ret = 0；

List<Pair>[] edge = new List[vars];
for(int i = 0; i < vars; i ++){
    edge[i] = new ArrayList();
}

HashMap<Integer, List<Integer>> unLock = new HashMap();
List<Integer> list = unLock.getOrDefault(target, new ArrayList());

new int[X]; X大于0时，数组中全是0； X = 0时，是一个长度为0的空数组。

    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> ret = new ArrayList();
        process(nums, 0, new ArrayList(), ret);
        return ret;
    }

    public void process(int[] nums, int index, List<Integer> line, List<List<Integer>> ret){
        if(index == nums.length){
            ret.add(new ArrayList(line));//注意每次存储要创建一个新list，之前的list最后会变为空
            return;
        }
        process(nums, index + 1, line, ret);
        line.add(nums[index]);
        process(nums, index + 1, line, ret);
        line.remove(line.size() - 1);
    }
}

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List<String>> map = new HashMap();
        for(String str : strs){
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String sortedstr = String.valueOf(chars);
            //或者使用new String(chars)不可以用chars.toString();
            List<String> list = map.getOrDefault(sortedstr, new ArrayList());
            list.add(str);
            map.put(sortedstr, list);
        }
        return new ArrayList(map.values());
    }
}

new ArrayList(list)里面可以是List<Integer> 类型也可以是 char[]类型

class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> ret = new ArrayList();
        List<String> list = new ArrayList();
        char[] chars = s.toCharArray();
        process(chars, 0, list, ret);
        return ret;
    }

    public void process(char[] chars, int index, List<String> list, List<List<String>> ret){
        if(index == chars.length){
            ret.add(new ArrayList(list));
            return;
        }
        for(int i = index; i < chars.length; i ++){
            if(isP(chars, index, i)){
                list.add(new String(Arrays.copyOfRange(chars, index, i + 1)));
                process(chars, i + 1, list, ret);
                list.remove(list.size() - 1);
            }
        }
    }
    public boolean isP(char[] chars, int i, int j){
        if(i == j) return true;
        while(i < j){
            if(chars[i] != chars[j]){
                return false;
            }
            i ++;
            j --;
        }
        return true;
    }
}

LCR 060.前K个高频元素

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> map = new HashMap();
        for(int i = 0; i < nums.length; i ++){
           map.put(nums[i],map.getOrDefault(nums[i], 0) + 1); 
        }
        PriorityQueue<HashMap.Entry<Integer, Integer>> queue = new PriorityQueue<>(
            (a, b) -> b.getValue() - a.getValue()//没有分号
        );
        queue.addAll(map.entrySet());//注意技巧
        int[] ret = new int[k];
        for(int i = 0; i < k; i ++){
            ret[i] = queue.poll().getKey();
        }
        return ret;
    }
}