- 代码随想录:代码随想录
- 力扣:力扣 (LeetCode) 全球极客挚爱的技术成长平台
目录
01、代码随想录
00、琐碎知识点
01、数组
02、链表
03、哈希表
04、字符串
05、双指针法
06、栈与队列
6.1、栈
6.2、队列
07、二叉树
7.1、前中后序-递归遍历
7.2、二叉树层序遍历模板
7.3、节点的定义
08、回溯算法
09、贪心算法
10、动态规划
11、单调栈
12、图论
02、低代码平台调研
01、代码随想录
00、琐碎知识点
Arrays.asList() 是一个静态方法,用于将传入的参数转换为一个 List 对象。它的作用是将数组转换为一个固定长度的、不可变的 List,该 List 的底层实现仍然是原始数组,因此对数组或列表的修改都会影响到另一个。
这个方法通常用于将数组快速转换为 List,方便在需要 List 类型参数的方法中使用数组。例如:
String[] array = {"apple", "banana", "orange"};
List<String> list = Arrays.asList(array);
这段代码将一个字符串数组转换为一个字符串列表。此时对数组或列表的修改都会相互影响,因为它们共享相同的数据源。但需要注意的是,由于底层实现是基于原始数组的,所以返回的 List 是一个固定长度的列表,不能进行增加或删除元素的操作,否则会抛出 UnsupportedOperationException 异常。
set1.retainAll(set2)
是一个Set集合的方法调用,用于保留两个集合中都存在的元素,即在set1中仅保留那些也存在于set2中的元素。该方法会修改调用它的set1集合,使其只包含那些同时也存在于set2中的元素,而不包含set2中不包含的元素。举个例子,假设set1包含元素 {1, 2, 3, 4, 5},set2包含元素 {3, 4, 5, 6, 7},那么调用
set1.retainAll(set2)
后,set1将变成 {3, 4, 5},因为这些元素是同时存在于set1和set2中的。这个方法在集合操作中经常用于求交集。
//定义翻转函数
public void reverse(char[] ch, int i, int j) {for (; i < j; i++, j--) {char temp = ch[i];ch[i] = ch[j];ch[j] = temp;}
}
这两个方法是 Java 中常用的用于类型转换的静态方法:
Integer.parseInt(String s)
:
- 用于将字符串转换为整数类型。它将接受一个字符串参数,并尝试将该字符串解析为一个带符号的十进制整数。
- 如果解析成功,它将返回相应的整数值。
- 如果字符串不是有效的表示整数的格式,或者包含超出整数范围的字符,它将抛出
NumberFormatException
异常。
String.valueOf(Object obj)
:
- 将指定的对象转换为字符串表示形式。
- 如果传入的对象为 null,则返回字符串 "null"。
- 否则,它会调用对象的
toString()
方法来获取字符串表示形式。这些方法在实际编程中经常用于数据类型之间的转换。例如,
parseInt()
可用于将用户输入的字符串转换为整数,而valueOf()
可用于将其他数据类型(如整数、浮点数、布尔值等)转换为字符串。
//0347
Map<Integer, Integer> map = new HashMap<>();//key:数字,value:出现到频次、
map.put(curNum, map.getOrDefault(curNum, 0) + 1);ArrayList<Map.Entry<Integer, Integer>> list = new ArrayList(map.entrySet());
Collections.sort(list, (a, b) -> {//根据value进行排序return b.getValue() - a.getValue();
});Map<Integer, Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
//在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
//出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {//大顶堆需要对所有元素进行排序pq.add(new int[]{entry.getKey(), entry.getValue()});
}
01、数组
Java 数组 | 菜鸟教程
int[] array1;//声明整数数组
array1 = new int[]{1, 2, 3, 4, 5};//初始化数组int[] array2 = new int[]{1, 2, 3, 4, 5};int[] array3 = new int[99];return new int[]{i, j};
for(type element: array) {System.out.println(element);
}
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
02、链表
public class ListNode {// 结点的值int val;// 下一个结点ListNode next;// 节点的构造函数(无参)public ListNode() {}// 节点的构造函数(有一个参数)public ListNode(int val) {this.val = val;}// 节点的构造函数(有两个参数)public ListNode(int val, ListNode next) {this.val = val;this.next = next;}
}
03、哈希表
Set<Integer> record = new HashSet<>();
map的用法
在Java中,
Map
是一种常用的数据结构,用于存储键值对。以下是Map
接口中一些常用的方法:
put(K key, V value): 将指定的键值对添加到Map中,如果键已存在,则替换对应的值。
get(Object key): 返回指定键所映射的值,如果键不存在,则返回null。
containsKey(Object key): 如果Map中包含指定的键,则返回true,否则返回false。
containsValue(Object value): 如果Map中包含一个或多个键所映射的值等于指定值,则返回true,否则返回false。
remove(Object key): 删除Map中指定键所映射的键值对,并返回该键所对应的值,如果键不存在,则返回null。
keySet(): 返回Map中所有键构成的Set集合。
values(): 返回Map中所有值构成的Collection集合。
entrySet(): 返回Map中所有键值对构成的Set集合,每个元素都是一个Map.Entry对象,表示一个键值对。
size(): 返回Map中键值对的数量。
isEmpty(): 如果Map中不包含键值对,则返回true,否则返回false。
//0347
Map<Integer, Integer> map = new HashMap<>();//key:数字,value:出现到频次、
map.put(curNum, map.getOrDefault(curNum, 0) + 1);ArrayList<Map.Entry<Integer, Integer>> list = new ArrayList(map.entrySet());
Collections.sort(list, (a, b) -> {//根据value进行排序return b.getValue() - a.getValue();
});Map<Integer, Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
//在优先队列中存储二元组(num, cnt),cnt表示元素值num在数组中的出现次数
//出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2) -> pair2[1] - pair1[1]);
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {//大顶堆需要对所有元素进行排序pq.add(new int[]{entry.getKey(), entry.getValue()});
}
04、字符串
s = s.replaceAll("\\s+", " ");//将字符串s中所有连续的空白字符替换为单个空格,从而实现将多个连续空白字符合并为一个空格的效果。
String s;
int[] record = new int[26];
for (int i = 0; i < s.length(); i++) {record[s.charAt(i) - 'a']++;
}
Integer.parseInt(String s);//字符串转换为整数
String.valueOf(Object obj);//将指定的对象转换为字符串表示形式。
05、双指针法
略
06、栈与队列
6.1、栈
Stack<String> stack = new Stack<String>();
6.2、队列
Deque<Character> deque = new LinkedList<Character>();
Deque<Character> deque = new LinkedList<>();
deque.push('a');
deque.pop();
deque.peek();
deque.isEmpty();
Deque
接口代表了一个双端队列(Double Ended Queue),它支持在队列两端添加、删除和检查元素。LinkedList
类实现了Deque
接口,因此你可以使用LinkedList
来创建一个Deque
实例。
deque.push('a'):将元素
'a'
推入双端队列的开头。deque.pop():移除并返回双端队列的第一个元素。在这种情况下,它会移除并返回队列开头的元素。
deque.peek():返回双端队列的第一个元素,但不移除。这个方法允许你查看队列开头的元素,但不会对队列做出任何修改。
deque.isEmpty():检查双端队列是否为空。如果队列中没有元素,则返回
true
,否则返回false
。
Queue<Integer> queue;//和栈中保持一样元素的队列
queue1 = new LinkedList<>();Queue<Integer> queue = new LinkedList<>();//【用的最多】queue.add();
queue.size();
queue.push();
queue.poll();
queue.peek();
queue.offer();
queue.isEmpty();Queue<Integer> queue = new ArrayDeque<>();
07、二叉树
7.1、前中后序-递归遍历
// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {public List<Integer> preorderTraversal(TreeNode root) {List<Integer> result = new ArrayList<Integer>();preorder(root, result);return result;}public void preorder(TreeNode root, List<Integer> result) {if (root == null) {return;}result.add(root.val);preorder(root.left, result);preorder(root.right, result);}
}// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();inorder(root, res);return res;}void inorder(TreeNode root, List<Integer> list) {if (root == null) {return;}inorder(root.left, list);list.add(root.val); // 注意这一句inorder(root.right, list);}
}// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> res = new ArrayList<>();postorder(root, res);return res;}void postorder(TreeNode root, List<Integer> list) {if (root == null) {return;}postorder(root.left, list);postorder(root.right, list);list.add(root.val); // 注意这一句}
}
//Definition for a Node.
class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};class Solution {//589.N叉树的前序遍历public List<Integer> preorder(Node root) {List<Integer> res = new ArrayList<>();helper(root, res);return res;}public void helper(Node root, List<Integer> res) {if (root == null) {return;}res.add(root.val);for (Node ch : root.children) {helper(ch, res);}}
}
7.2、二叉树层序遍历模板
队列和集合的声明:
List<List<Integer>> res = new ArrayList<>();
List<List<Integer>> res = new ArrayList<List<Integer>>();
Deque<Node> deque = new LinkedList<>();
class Solution0102 {//力扣102.二叉树的层序遍历public List<List<Integer>> levelOrder(TreeNode root) {Deque<TreeNode> deque = new LinkedList<>();if (root != null) {deque.push(root);}List<List<Integer>> res = new ArrayList<List<Integer>>();while (!deque.isEmpty()) {int size = deque.size();ArrayList<Integer> tempList = new ArrayList<Integer>();while (size-- > 0) {//for (int i = 0; i < size; i++) {TreeNode treeNode = deque.poll();tempList.add(treeNode.val);if (treeNode.left != null) {deque.offer(treeNode.left);}if (treeNode.right != null) {deque.offer(treeNode.right);}}res.add(tempList);}return res;}
}
7.3、节点的定义
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;}
}
import java.util.List;/*** 429.N叉树的层序遍历*/
public class Node {public int val;public List<Node> children;public Node() {}public Node(int _val) {val = _val;}public Node(int _val, List<Node> _children) {val = _val;children = _children;}
};
public class Node2 {public int val;public Node2 left;public Node2 right;public Node2 next;public Node2() {}public Node2(int _val) {val = _val;}public Node2(int _val, Node2 _left, Node2 _right, Node2 _next) {val = _val;left = _left;right = _right;next = _next;}
};
08、回溯算法
略
09、贪心算法
略
10、动态规划
略
11、单调栈
略
12、图论
略
02、低代码平台调研
芋道
- 芋道源码 —— 纯源码解析博客
- https://github.com/YunaiV
- 芋道源码 (zhijiantianya) - Gitee.com