数据结构

  • 数组

    	ArrayList`<Integer>`arr=new ArrayList<>();int[]c=new int[3];数组建立
    
    	arr.add(99);数组增加
    
    	arr.toArray(a);集合变成数组类型
    
    	arr.add(3,99);数组插入
    
    	arr.get(3);获得元素值
    
    	arr.set(3,22);改变元素值
    
    	arr.remove(3);移除某索引的元素
    
    	Collections.reverse(arr);反转一个arr
    
    	arr.size();长度				普通数组长度为length
    
    	arr.contains(99);是否含有某元素
    
    	Collections.sort(arr);集合类的排序
    
    	Arrays.sort(c);普通排序
    
    	Arrays.fill(c, 1);填充数组c的所有值为1
    
    	二维数组排序第一列按升序排列第一列相同则第二列按升序排列
    	compare方法返回值int类型返回值大于0交换两数小于零排序正确等于0两数相等
    
    	Arrays.sort(arr, new Comparator<int[]>() { 		
         public int compare(int[] e1, int[] e2) {
    	// 如果第一列元素相等,则比较第二列元素
    	if (e1[0]==e2[0]) return e1[1]-e2[1];   // e1[1]-e2[1]表示对于第二列元素进行升序排序
    	return e1[0]-e2[0];                     
    	}
    
        Arrays.sort(intervals,new Comparator<int[]>(){//两数相减或相加会产生int值溢出,因此通过比较后,直接返回-1,0,1  
            public int compare(int[]e1,int[]e2){// e1[0]-e2[0]表示对于第一列元素进行升序排序
                if(e1[0]>e2[0]){
                    return 1;
                }else if(e1[0]==e2[0]){
                    return 0;
                }else{
                    return -1;
                }
            }
        }); 
    
         Arrays.sort(intervals, (e1, e2) -> Integer.compare(e1[0], e2[0]));//上面可简写
    
    	Arrays.sort(strings,(s1,s2)-> (s1+s2).compareTo(s2+s1));
    
    	Collections.sort(lines, (l1, l2)->{    //集合排序
            return l1[0] != l2[0] ? l1[0] - l2[0] : l1[1] - l2[1];
        });
    
    
        List<String>[] lists = new ArrayList[5]; 
        for (int i = 0; i < lists.length; i++) { lists[i] = new ArrayList<>(); }
    
  • 链表

      LinkedList<Integer>list=new LinkedList<>();链表建立
    
      list.add(1);加入链表
    
      list.add(2,99);插入链表
    
      list.get(2);获得索引的元素
    
      list.indexOf(99);获得某元素的索引
    
      list.set(2,88);改变某元素
    
      list.remove(2);移除某元素//填索引值
    
      list.size()获得长度
    
      new LinkedList<>(track)); 把track集合的值放入匿名集合中
    
  • 队列

    Queue<Integer>queue=new LinkedList<>();队列建立
    	queue.add(1);添加元素
    	queue.peek();获取元素
    	queue.poll();移除元素
    	queue.isEmpty();判断是否为空
    	queue.size();队列长度
    
  • Deque<Integer> stack = new ArrayDeque<>();栈的建立
    
    	stack.push(1);添加元素
    
    	stack.peek();获得元素
    
    	stack.pop();移除元素
    
    	stack.size();栈的长度
    
    	stack.isEmpty();判断栈是否为空
    
  • 哈希表

    HashMap<Integer,String>  map=new HashMap<>();哈希表的建立
    
    map.put(1,"wang");增加元素
    
    map.put(1,"yu");改变元素
    
    map.remove(1);移除元素
    
    map.get(1);获取元素
    
    map.containsKey(1);检查元素
    
    map.size();数据长度
    
    map.isEmpty();判断哈希表是否为空
    
    map.keySet();哈希表的索引值遍历时用 没有按顺序
    
    map.values();哈希表的值
    
    map.getOrDefault(key,defaultValue); 方法获取指定 key 对应对 value如果找不到 key 则返回设置的默认值
    
  • 字符串

    String a="abcd";
    
    char[]arr=a.toCharArrray();变成数组
    
    String str=new String(arr);变成字符串
    
    int c1=a.length();表示长度
    
    char c1=a.charAt();取字符串的某一个字符
    
    String c1=a.substring(x,y);取字符串a从索引x到索引y-1的字符串
    
    String c2=s1.append("adv");在字符串s1后面加adv
    
    String c=String.valueOf(nums[i]);int类型变String类
    
    Integer.parseInt(str);string类型变int类
    
    trim();去字符串的两边空格
    
    split();将一个**字符串**分割为子字符串,结果作为字符串数组返回
    
    i的二进制第j位是否为1i>>j&1
    
    int index=a.indexOf(" ");获得a字符串中" "的索引
    
  • 集合:不能重复

    HashSet<Integer> set=new HashSet<>();创建集合
    
    set.add(2);添加元素
    
    set.contains(2);检查元素
    
    set.remove(2)移除元素
    
    set.size();集合中元素的个数
    
  • PriorityQueue<Integer>minHeap=new PriorityQueue<>();创建堆
    
    PriorityQueue<Integer>maxHeap=new PriorityQueue<>(Collectoins.reverseOrder());
    
    PriorityQueue<int[]>maxpq=new PriorityQueue<>(
    			(int[]pair1,int[]pair2)->{
                    return pair2[1]-pair1[1];
                });
            
    minHeap.add(1);加入元素
    
    minHeap.peek();获取元素
    
    minHeap.poll();删除元素
    
    minHeap.size();堆的长度
    
    minHeap.isEmpty();判断堆是否为空
    

ACM模式

  • 导入类型

    import java.util.*;
    
  • 全局只能new出一个Scanner对象

    Sacnner scanner=new Scanner(System.in)
    
  • 不确定出现几行

    while(scanner.hasNext()){     }
    
  • 读取总结:

    • nextInt(): 只读取整数类型数据, nextInt()在读取完输入后把光标放在读取数据的同一行,该数据的后面

      int arr=scanner.nextInt();
      
    • next(): 只读取到空格,不能读取被空格分开的两个单词(也就是不能读取空格),并且在读取完后把光标放在读取数据的同一行,该数据的后面。(同上)

      int arr[i]=scanner.next();//以空格为分割读取,返回值为String,和for结合使用 eg:1 2 3 
      
    • nextLine(): 读取整行的数据包括单词间的空格,到回车结束(也就是从开始读一整行包括回车),读取结束后,光标放在下一行开头

      Sting line = scanner.nextLine();
      String[]arr=line.split(" ");
      Integer.parseInt(arr[0]);//字符串转数组