蓝桥杯javaB组备赛

15届蓝桥杯备赛

java语法

基础IO框架

import java.util.*;
import java.IO.IOException;
import java.IO.BufferedReader;
public class Main{
    public static void main(String[] args)throws IOException{
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] inputStrs = reader.raedLine().split(" ");
        //Scanner scanner = new Scanner(System.in);
        //String[] inputStrs = scanner.nextLine().split(" ");
        return;
    }
}

java容器

List

1. ArrAyList
2. LinkedList
3. Vector

//增删改查方法
public void add(Object element) //增添元素
public void add(int index,Object element) //在指定位置增添元素
public boolean remove(Object o) //删除指定对象
public Object remove(int index) //删除指定位置的元素
public Object set(int index,Object element) //修改指定位置元素的值
public Object get(int index) //获取指定位置元素
public int indexOf(Object o) //获取指定元素的位置
public boolean contains(Object o) //判断指定元素是否存在
 
//其他常用方法
public int size() //获取容器中元素个数
public Iterator<E> iterator() //获取迭代器
public void clear() //清空元素

LinkList模拟队列和栈的接口

//模拟栈和队列操作
public void addFirst(Object o) //在链表头增添元素
public void addLast(Object o) //在链表尾增添元素
public Object removeFirst() //删除链表头元素，并返回该元素
public Object removeLast() //删除链表尾元素，并返回该元素
public boolean isEmpty() //判断链表是否为空
 
public void push(E e) //等价于addFirst()
public E pop() //等价于removeFirst()
public E getFirst() //获取链表首元素
public E getLast() //获取链表尾元素

Set

1. HashSet
2. TreeSet

//增删查方法
public void add(Object element) //增添元素
public boolean remove(object element) //删除元素
public boolean contains(Object o) //判断元素是否存在
 
//其他常用方法
public int size() //获取容器中元素个数
public boolean isEmpty() //判断集合是否为空
public Iterator<E> iterator() //获取迭代器
public void clear() //清空元素

Map

1. HashMap
2. TreeMap

//增删查
public Object put(Object key,Object value) //增添元素
public Object remove(Object key) //删除元素,并返回键对应的值
public Object get(Object key) //获取键对应的值
public boolean containsKey(Object key) //判断指定键是否存在
public boolean containsValue(Object value) //判断指定值是否存在
 
//获取键、值、元素集合
public Collection values() //获取值集合
public Set KeySet() //获取键集合
public Set entrySet() //获取元素集合
 
//其他方法
public int size() //获取容器中元素个数
public boolean isEmpty() //判断容器是否为空
public void clear() //清空元素

Map 接口没有提供 iterator() 方法，其子接口 Entry 提供了 iterator() 方法，并且提供了获取键、值的方法，如下：

//Map.Entry接口主要方法
public Iterator<E> iterator() //获取迭代器
public Object getKey() //获取键
public Object getValue() //获取值
 
//调用案例
Iterator(Entry) iter=map.entrySet().iterator();
while(iter.hasNext()){
    Entry entry=iter.next();
    int key=(Integer)entry.getKey();
    int val=(Integer)entry.getValue();
}

其它容器常用方法

Arrays

public static int binarySearch(Object[] a, Object key) //二分查找（a已排序）
public static boolean equals(Object[] a, Object[] a2) //判断两数组是否完全一致
public static void fill(Object[] a, Object val) //在a中所有位置填充val
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) //在[fromIndex,toIndex)中填充元素val
public static String toString(Object[] a) //将数组a转换为字符串，如"[1, 2, 3]"
public static void sort(Object[] a) //改进的快速排序（升序）
public static void sort(Object[] a, int fromIndex, int toIndex) //对[fromIndex,toIndex)中的元素排序（升序）
public static <T> void sort(T[] a, Comparator<? super T> c) //自定义比较器排序

排序案例：升序排序直接调用 sort() ，降序排序需要实现比较器（Comparator ）接口

import java.util.Arrays;
import java.util.Comparator;
 
public class Sort{
	static Integer[] a= {5,8,4,2,9,3,1,6,7};
	static String[] s= {"Tom","John","Marry","Katty","Jerry"};
 
	public static void main(String[] args) {
		Arrays.sort(a); //1 2 3 4 5 6 7 8 9 
		Arrays.sort(s); //Jerry John Katty Marry Tom 
 
		Arrays.sort(a,new Comparator<Integer>() {
			public int compare(Integer o1, Integer o2) {
				return o2-o1;
			}				
		}); //9 8 7 6 5 4 3 2 1 
 
		Arrays.sort(s,new Comparator<String>() {
			public int compare(String o1, String o2) {
				return o2.compareTo(o1);
			}			
		}); //Tom Marry Katty John Jerry 
	}
}

优先队列（PriorityQueue）
首先import java.util.PriorityQueue

• PriorityQueue中放置的元素必须要能够比较大小 （只有实现了 Comparable 和 Comparator 接口的类才能比较大小），不能插入无法比较大小的对象，否则会抛出 ClassCastException 异常
• 不能插入 null 对象，否则会抛出 NullPointerException 异常
• 没有容量限制，可以插入任意多个元素，其内部可以自动扩容
• 插入和删除元素的时间复杂度均为 O(log2N)
• PriorityQueue底层使用了堆数据结构
  常用接口
  Java中的优先队列（PriorityQueue）是Java集合框架的一部分，它实现了Queue接口，并且使用堆数据结构来维护元素的优先级顺序。以下是一些常用的Java优先队列接口：

1. PriorityQueue()：创建一个空的优先队列。

PriorityQueue<Integer> pq = new PriorityQueue<>();

2. PriorityQueue(Comparator<? super E> comparator)：创建一个空的优先队列，并使用指定的比较器对元素进行排序。

Comparator<Integer> reverseOrder = Collections.reverseOrder();
PriorityQueue<Integer> pq = new PriorityQueue<>(reverseOrder);

3. add(E e)：将指定的元素插入此优先队列。

pq.add(5);

4. offer(E e)：将指定的元素插入此优先队列（如果立即可行且不会违反容量限制），成功时返回true。

boolean success = pq.offer(10);

5. poll()：检索并删除此队列的头，如果此队列为空，则返回null。

Integer head = pq.poll();

6. peek()：检索但不删除此队列的头，如果此队列为空，则返回null。

Integer head = pq.peek();

7. remove(Object o)：从队列中移除指定元素的单个实例（如果存在）。

boolean removed = pq.remove(5);

8. contains(Object o)：如果此队列包含指定的元素，则返回true。

boolean contains = pq.contains(10);

9. size()：返回队列中的元素数量。

int size = pq.size();

10. isEmpty()：如果队列不包含任何元素，则返回true。

boolean isEmpty = pq.isEmpty();

11. clear()：从队列中移除所有元素。

pq.clear();

这些接口为Java优先队列提供了基本的操作，使得你可以方便地进行元素的添加、删除、查看以及队列的状态查询等操作。注意，由于优先队列是基于堆实现的，所以元素在队列中的位置可能会随着元素的插入和删除而改变，以满足优先级的顺序。

Collections

1. Collections类对Collection提供的方法

public static Object max(Collection coll) //获取最大值
public static Object min(Collection coll) //获取最小值

2. Collections类对List对象提供的方法

public static int binarySearch(List list, Object key) //查找元素
public static void copy(List dest, List src) //将src复制给dest
public static void fill(List list, Object obj) //在list中填充obj
public static void reverse(List list) //列表元素倒置
public static void sort(List list) //升序排序
public static <T> void sort(List<T> list, Comparator<? super T> c) //自定义比较器排序

3. Collections类提供的集合同步处理方法

public static Collection synchronizedCollection(Collection c) //Collection对象同步
public static List  synchronizedList(List list) //List对象同步
public static Set  synchronizedSet(Set s) //Set对象同步
public static Map  synchronizedMap(Map m) //Map对象同步

常用数据结构

单链表

class SinglyLinkedList {
    class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    private Node head;

    public void insert(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }

    public boolean search(int key) {
        Node temp = head;
        while (temp != null) {
            if (temp.data == key) {
                return true;
            }
            temp = temp.next;
        }
        return false;
    }

    public void delete(int key) {
        Node temp = head, prev = null;
        if (temp != null && temp.data == key) {
            head = temp.next;
            return;
        }

        while (temp != null && temp.data != key) {
            prev = temp;
            temp = temp.next;
        }

        if (temp == null) return;

        prev.next = temp.next;
    }
}

双链表

栈

队列

单调栈

单调队列

KMP

Trie

并查集

堆

哈希表

二叉树

树状数组

线段树

平衡二叉树

常用算法

二分

排序

高精度（java不太需要）

前缀和

差分

双指针

位运算

离散化

区间合并

深度优先搜索

广度优先搜索

拓扑排序

最短路算法

最小生成树

匈牙利算法

最近公共祖先

数学知识

动态规划算法

贪心算法