目录
常规代码模板
核心代码模式
函数名，输入参数，输出参数类型都已经写好，只需要写函数体即可。
ACM模式
啥都没有，需要自己写
这里提供一个模板，主要是读入示例，自己构建出输入参数，那么就可以转化为核心代码模式了，方便过渡。
读入大致是分为两类，数字和字符串。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);// 获取控制台对象
int T = sc.nextInt();//如果一个示例有多组数据 T就是组数
while(T-- >0){// 循环读入T组数据，处理后输出每组数据的结果
int n = sc.nextInt();// 该示例中 需要先读取一个 n 表示接下来n个数是x数组
int[] nums = new int[n];
String[] strs = new String[n];
for(int i = 0; i < n; ++i){
nums[i] = sc.nextInt();
}
for(int i = 0; i < n; ++i){
strs[i] = sc.nextLine();// nextLine()读取字符串
}
System.out.println(getResult(nums,strs));
}
}
private static int getResult(int[] nums, String[] strs) {
//核心代码模式
// write your code here
return -1;
}
}
Map Set 遍历
/*
* 测试List遍历的方式
* */
public class TestArrayList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("aa");
list.add("bb");
list.add("cc");
//方式一，for循环遍历,通过get()方法
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//方式四,增强for循环 foreach
for (String str : list) {
System.out.println(str);
}
//方式五，转化数组
String[] a = new String[3];
String[] aa = list.toArray(a);
for (int i = 0; i < aa.length; i++) {
System.out.println(aa[i]);
}
}
}
————————————————
版权声明：本文为CSDN博主「yuyinghe0612」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yuyinghe0612/article/details/80549443public class TestHashMap {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("a", "2000");
map.put("b", "3000");
//方式一、在for-each循环中使用entrySet来遍历
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> entry : entrySet) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println("key=" +key+" value="+value);
}
//方式二、在for-each循环中通过键找值遍历
for (String key : map.keySet()) {
System.out.println("key=" + key+" value="+map.get(key));
}
//只打印键值keys
for (String key : map.keySet()) {
System.out.println("key=" + key);
}
//只打印values
for (String value : map.values()) {
System.out.println("value=" + value);
}
}
}
————————————————
版权声明：本文为CSDN博主「yuyinghe0612」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yuyinghe0612/article/details/80549443map不能用增强for循环。
自定义比较器
算法题中会出现可以使用库函数sort 的情景，不过往往不是简单的sort，在java中
sort默认是升序，如何实现降序呢？ 如果现在是对nums(int[2]) 中的第0列数据升序，在此基础上第1列数据降序，又怎么做呢？
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
/**
* @Description
* @create 2022/2/14 - 21:27
*/
public class compareDemo {
public static void main(String[] args) {
int[][] nums = new int[3][2];
nums[0][0] = 12;
nums[0][1] = 0;
nums[1][0] = 15;
nums[1][1] = 50;
nums[2][0] = 15;
nums[2][1] = 90;
for (int[] num : nums) {
System.out.println(num[0] + " " + num[1]);
}
System.out.println("=========排序后==========");
Arrays.sort(nums,new Comparator<int[]>(){
@Override
public int compare(int[] o1, int[] o2) {
if(o1[0]!=o2[0]){
return o1[0] - o2[0];// 升序
}else{
return o2[1] - o1[1];// 降序
}
}
});
for (int[] num : nums) {
System.out.println(num[0] + " " + num[1]);
}
Integer[] nums1 = new Integer[]{5,7,8,2,3};
Arrays.sort(nums1);// 升序
for (int i : nums1) {
System.out.println(i);
}
Arrays.sort(nums1, Collections.reverseOrder());// 降序
for (int i : nums1) {
System.out.println(i);
}
Arrays.sort(nums1,new Comparator<Integer>(){
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; // 降序
}
});
for (int i : nums1) {
System.out.println(i);
}
}
}
sort 自定义比较器不能对 int[] 等基本数据类型的数组进行排序，只适用于object[]。
所以对于int[] 要不然转化为引用数据类型的数组，再用库函数，要不然自己写快排之类的算法。
建立大跟堆、小根堆
import java.util.Comparator;
import java.util.PriorityQueue;
/**
* @Description
* @create 2022/2/14 - 21:58
*/
public class heapDemo {
public static void main(String[] args) {
PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;//小根堆
}
});
pq.add(1); pq.add(5); pq.add(10);
PriorityQueue<Integer> pq2 = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;//大根堆
}
});
pq2.add(1); pq2.add(5); pq2.add(10);
System.out.println(pq.peek());
System.out.println(pq2.peek());
int[][] nums = new int[3][2];
nums[0][0] = 12;
nums[0][1] = 0;
nums[1][0] = 15;
nums[1][1] = 50;
nums[2][0] = 15;
nums[2][1] = 90;
for (int[] num : nums) {
System.out.println(num[0] + " " + num[1]);
}
PriorityQueue<int[]> pqArr = new PriorityQueue<>(new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
if(o1[0]!=o2[0]){
return o1[0] - o2[0];// 升序
}else{
return o2[1] - o1[1];// 降序
}
}
});
pqArr.add(nums[0]);
pqArr.add(nums[1]);
pqArr.add(nums[2]);
while(!pqArr.isEmpty()) {
System.out.println(pqArr.peek()[0] + " " + pqArr.poll()[1]);
}
}
}