leetcode中常用的简单数据结构（JAVA）

记录平时刷题正好用到的数据结构以及常用的函数(总是和其他语言的记混)。 

1. Stack 栈 

(1) 定义

Stack<Integer> stack = new Stack<>(); 

(2) 常用函数： 

stack.push(1); // 入栈

stack.pop(); // 出栈

stack.peek(); // 查看要出栈的数据（本身没有出栈）

stack.isEmpty(); // 查看栈是否为空，或者用stack.size() == 0

(3) 什么题目用： 单调栈题目等

2. Queue 队列

(1) 定义

Queue<Integer> queue = new LinkedList<>(); 

(2) 常用函数： 

queue.add(1); // 队列末尾添加, 如果有容量限制，满容量报错

queue.offer(1); // 队列末尾添加, 如果有容量限制，满容量会返回false

queue.remove(); // 移除队列开头的数据（先入先出）遇到队列空会报错

queue.poll(); // 得到出队列的那个数据，遇到队列空会返回null

queue.peek(); // 查看第一个要出的数（本身没有移除操作）

queue.isEmpty(); // 查看栈是否为空，或者用queue.size() == 0

(3) 什么题目用： BFS模板等

3. 优先队列 PriorityQueue

(1) 定义

PriorityQueue<Integer> pq = new PriorityQueue<>(); //队列自动排序

(2) 常用函数： 

pq.add(1); // 添加, 其实和offer区别不大，内部调用了

pq.offer(1); // 添加

pq.remove(); // 移除队列开头的数据（先入先出）会报异常

pq.poll(); // 得到出队列的那个数据，遇到队列空会返回null

pq.peek(); // 查看第一个要出的数（本身没有移除操作）

pq.isEmpty(); // 查看栈是否为空，或者用pq.size() == 0

(3) 自定义排序, 比如反序或者自定义的类

new PriorityQueue<Integer> pq = new PriorityQueue<>(a, b -> a - b);

4. Map 

(1) 定义 Map<Integer, Integer> map = new HashMap<>(); 

(2) 常用函数： 

map.put(1, 1); //添加

map.containsKey(1); //查找是否有key 

map.get(1); // 通过key找到值，通常要用conatinsKey先看key存在再找，否则返回null

map.getOrDefault(1, 0); // 很常用的函数，查找如果没有返回一个默认值
List<String> list = map.getOrDefault(curKey, new ArrayList<String>());
// 注意复杂的数据结构我们还需要put回去的

这个我喜欢用时不想写containsKey，并且写出来非常简单，比如统计字符串中的字母的出现次数。

比如遍历时候当前为字母为'a'我们可以： map.put(map.getOrDefault('a', 0) + 1); 

这样如果'a'不存在于map, 最后map中的'a'的值为1， 如果存在'a'的值为2，那么最后结果'a'

的值为3，一行就解决了。（当然也可以用containsKey来写）

(3) 循环 (还有forEach, iterator等)

(a) entrySet

for (Map.Entry<Integer, Integer> e : map.entrySet()) {

        e.getKey();

        e.getValue();

}

(b) keySet

for (int key : map.keySet()) {

        map.get(key);

}

(4) 转换

//比如我们定义Map
Map<String, List<String>> map = new HashMap<>();
// 我们想要将所有value放入一个List
// 可以用map.values()函数
new ArrayList<List<String>>(map.values());
// 解释 map.values()返回了 Collection<String>， 其可以当作ArrayList参数

5. Map的变种 TreeMap

(1). 定义与解释：

TreeMap<Integer, String> treeMap = new TreeMap<>();

TreeMap中它的key是进行过排序的,整体添加删除

(2). 函数： 

与Map类似它有get, put, containsKey, getOrDefault函数，其中独特的是

treeMap.lastKey(); 返回排在最后的key

treeMap.firstKey(); 返回排在第一个的key

treeMap.higherKey(10); 返回大于10的第一个key

treeMap.ceilingKey(10); 返回大于等于10的第一个key

treeMap.lowerKey(10); 返回小于10的第一个key

treeMap.floorKey(10); 返回小于等于10的第一个key

6. Set

(1) 定义：

Set<String> set = new HashSet<>();

(2) 函数：

set.add("a"); //添加数据"a"

set.remove("a"); //删除数据"a"

set.contains("a"); //是否有数据"a"

set.size(); //返回set的大小

set.toArray(); //转化为数组返回

(3) 循环遍历：

直接for循环：

for (String s : set) {

}

迭代器：

Iterator<String> it = set.iterator();

while (it.hasNext()) {

        String cur = it.next(); 

} 

forEach方法：

set.forEach(ele -> System.out.println(ele));

7. Set的变种TreeSet

定义：内部的数据已经进行排序

TreeSet<String> ts = new TreeSet<>();

如果我们想改变默认顺序，比如实现字符串倒序

Comparator<String> c = (str1, str2) -> str2.compareTo(str1);
TreeSet<String> ts = new TreeSet<>(c);
//或者直接
TreeSet<String> ts = new TreeSet<>((str1, str2) -> str2.compareTo(str1));

函数

可以用set的函数, add, remove, size等

ts.first(); //返回排序第一个的数据

ts.last(); //返回排序最后一个的数据

ts.floor(10); //返回小于等于10的最大数据

ts.lower(10); //返回小于10的最大数据

ts.ceiling(10); //返回大于等于10的最小数据

ts.higher(10);//返回大于10的最小数据

注意和treeMap中的函数名字有差别，比如lower()和lowerKey()

8. 数组和ArrayList相关

简单数组:

int[] list = new int[10]; //固定长度为10，默认值

int[] list = new int[]{1, 2, 3}; //自定义数值初始化
int[] list = {1, 2, 3}; //自定义数值初始化

list[3]; //读取

list[3] = 2; //赋值

int[][] tl = new int[2][2]; //二维数组

list.length; //长度

排序：

Arrays.sort(list); //在原基础上排序，注意如果想改变排序规则，array首先需要是类（int -> Integer）,然后添加比较器或者自带的Colelctions.reverseOrder();

Arrays.sort(list, Collections.reverseOrder()); //比如list是String[]的

ArrayList定义： 

ArrayList<Integer> list = new ArrayList<>();

函数

list.add("test"); //添加

list.set(1, "test"); //更新

list.get(1); //获取， 注意JAVA中ArrayList不可以用list[1]

list.size(); //长度,  注意JAVA中ArrayList不可以用length

list.remove(1); //移除

ArrayList 排序：

Collections.sort(list); //排序，在原本直接修改

ArrayList转化为array：

（a）两者类相同

String[] arr = new String[list.size()]; //或者0
arr = list.toArray(arr);

String[] arr = list.toArray(new String[list.size()]);

(b) 两者类有区别，比如Integer和int，可以用stream或者手动循环

int[] array = list.stream().maoToInt(Integer::intValue).toArray();

ArrayList拷贝

new ArrayList<Integer>(preArray); //浅拷贝或者用clone

9. Deque相关

Deque是双端队列，比queue功能更加丰富。 queue是先进先出是单向的，比如单项列表，而deque更类似于双向列表，可以直接对起始点何最后点进行操作。 我们可以用deque来替代stack。

定义： 

Deque<Integer> deque = new ArrayDeque<>();

函数：

deque.addFirst(1);//添加开头

deque.addLast(2);//添加结尾

deque.getFirst(); //得到开头数据(不删除数据)，没有数据则报错

deque.getLast(); //得到右端数据（不删除数据）

deque.peekFirst(); //得到数据不删除，没有数据则返回null（区别）

deque.peekLast(); 

int first = deque.removeFirst(); //得到并删除数据

int last = deque.removeLast(); 

10. StringBuilder

JAVA中的String是不可变的并存在String pool中，当我们需要复杂操作时候需要StringBuilder

StringBuilder sb = new StringBuilder(); //创建

StringBuilder sb = new StringBuilder("ASDF"); //根据现有String来创建

sb.toString(); //转化为String

sb.append("asdf"); //往后加

sb.charAt(3); //get

sb.insert(1); 

sb.replace(5, 7, "ASD");

sb.delete(5, 6); 

sb.deleteCharAt(7);

sb.setCharAt(7, 'I'); //set