java数据结构

java

• 基础
• 输入输出
• 数组&链表&集
• [集 Set, HashSet](#集 Set, HashSet)
• 双向链表
• [队列 Queue, LinkedList](#队列 Queue, LinkedList)
• 矩阵
• 二叉树
• [哈希表 Map, HashMap](#哈希表 Map, HashMap)
• [栈 Deque, LinkedList](#栈 Deque, LinkedList)
• [大顶堆 PriorityQueue, PriorityQueue](#大顶堆 PriorityQueue, PriorityQueue)

基础

1.循环

for (int num:nums) {
	// continue跳过这次循环
    if (i > 0) continue;
}

2.取string特定位置的char，截取部分字符串

//取字符串特定位置字符
char c = s.charAt(5);
//截取部分字符串，范围是 [a, b)，即从 a 开始，到 b-1 结束
string str = s.substring(ansL, ansR);

3.初始化int最小值（赋值最大值）

int len = Integer.MAX_VALUE;

4.位运算

//计算l与r除2
int mid = (l + r) >> 1;
//计算2的num次方
int result = 1 << num;

//异或: a ^ 0 = a; a ^ a = 0
int result = a ^ b;

5.计算任意数的幂

//2的num次方，返回double
double result = Math.pow(2, num);

6.交换集合中两个位置的元素

//将集合 output 中索引为 first 和索引为 i 的两个元素互换
Collections.swap(output, first, i);

7.StringBuilder对象

append();//追加内容。
insert();//插入内容。
delete();//删除内容。
reverse();//反转字符串。
toString();//转换为 String

输入输出

输入

Scanner sc = new Scanner(System.in);
// 读取一个整数
int n = sc.nextInt();
// 读取一个字符串
String s = sc.next();
// 读取一行字符串，例：2，4
String line = sc.nextLine();
String[] parts1 = line.split(","); // 按逗号分隔
int a = Integer.parseInt(parts1[0]); // 第一个整数
int b = Integer.parseInt(parts1[1]);
// 读取一个浮点数
double d = sc.nextDouble();

输出

System.out.println();

数组&链表&集

1.创建数组，求数组长度，比较数组是否相同

int[] arr1 = {1,2,3,4};
int[] arr2 = new int[4];

//求int[]长度
h1 = arr1.length;
//String求长度
h2 = str.length();

//比较数组是否相同
Arrays.equals(arr1, arr2);
//比较string是否相同
str1.equals(str2);

1.5.二维数组排序

//普通排序
Arrays.sort(nums);
//排序规则是根据每个区间的起始值（第一个元素）升序排列，结合了匿名内部类实现 Comparator 接口来定义排序规则
Arrays.sort(intervals, new Comparator<int[]>() {
    public int compare(int[] interval1, int[] interval2) {
        return interval1[0] - interval2[0];
    }
});

2.创建列表

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

2.5.嵌套列表

//例：[[1],[1,2],[3,2,1]]
List<List<Integer>> list=new ArrayList<>();
// 添加子列表
List<Integer> sublist1 = new ArrayList<>();
sublist1.add(1);
sublist1.add(2);
list.add(sublist1);
//读取，从0开始
sublist1.get(1);

3.字符串string转数组char[]，并排序

char[] array = str.toCharArray();
Arrays.sort(array);//静态排序方法

3.1.数组char[]转字符串string

String sortedStr = new String(array);

3.2.数组 int[]/String[] 转列表 List<int/String>

String[] array = {"apple", "banana", "cherry"};
List<String> list = Arrays.asList(array);
//或
List<int> list = Arrays.asList(1, 3, 5);

3.3.列表List<int[]>转数组int[][]

List<int[]> merged = new ArrayList<int[]>();
int[][] a = merged.toArray(new int[merged.size()][]);

集 Set, HashSet

1.创建Set

//set保证数组内没有重复元素
Set<Integer> num_set = new HashSet<Integer>();
for (int num : nums) {
	num_set.add(num);//加入元素
	num_set.remove(num);//移除元素
}
//判断set里是否存在num-1
boolean con = num_set.contains(num - 1);

2.List与Set区别

特性	List	Set
是否允许重复元素	允许	不允许
存储顺序	有序（按插入顺序）	通常无序
索引访问	支持	不支持
适用场景	需要顺序存储或按索引访问	需要去重或快速查找

双向链表

有指向前一个节点和后一个节点的指针。

可以用于维护缓存中数据的访问顺序。最近访问的节点放在链表头部，最久未访问的节点放在链表尾部。

class DLinkedNode {
    int key;
    int value;
    DLinkedNode prev;
    DLinkedNode next;
    public DLinkedNode() {}
    public DLinkedNode(int _key, int _value) {key = _key; value = _value;}
}

伪头部和伪尾部节点

head 和 tail 是哨兵节点（不存储实际数据），用于简化双向链表的操作。

private DLinkedNode head, tail;
head.next = tail;
tail.prev = head;

队列 Queue, LinkedList

队列遵循先进先出的原则，即最先进入队列的元素最先被移除。

新元素从队尾（rear）加入，从队头（front）移除

Queue<TreeNode> queue = new LinkedList<TreeNode>();
//将元素插入队尾
queue.offer(root);
//移除并返回队头元素
queue.poll();
//返回队头元素但不移除
queue.peek();
//判断队列是否为空
if(queue.isEmpty())
//得到队列长度
queue.size();

矩阵

1.生成矩阵，获得矩阵长，高

int h=board.length; //长
int w=board[0].length; //高
boolean[][] visited=new boolean[h][w];

二叉树

基本结构

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;
	}
}

哈希表 Map, HashMap

存储的内容是键值(key-value)映射

1.创建哈希表（第一个参数为key属性，第二个为value属性）

Map<String,List<String>> map = new HashMap<String,List<String>>();

2.设置key以及对应value的值

//array可以是char[]
String key = new String(array);
//从HashMap中获取当前key对应的value，如果key不存在，则创建一个新的空列表
List<String> list = map.getOrDefault(key, new ArrayList<String>());
// 将当前字符串添加到对应的value列表中
list.add(str);

// 将更新后的列表放回HashMap中
map.put(key, list);
//获得key对应的value
map.get(key);
//移除map中的key以及对应value
map.remove(key);

3.输出map

//将HashMap中的所有值转换为一个List并返回
return new ArrayList<List<String>>(map.values());

4.判断字符串是否在key内

boolean a = map.containsKey(s.charAt(r))

5.获取map的键值对迭代器以遍历map

Iterator iter = map.entrySet().iterator(); 
// 遍历每个键值对
while (iter.hasNext()) { 
	// 获取当前键值对
    Map.Entry entry = (Map.Entry) iter.next();

    // 获取当前字符
    Character key = (Character) entry.getKey();     
    // 获取当前字符在 t 中的出现次数
    Integer val = (Integer) entry.getValue(); 
}

栈 Deque, LinkedList

1.定义栈

//存储character类型对象
Deque<Character> stack=new LinkedList<Character>();

2.栈的压入，移除，读取元素

//元素压入栈顶 (队列最前面)
stack.push('A'); 
//移除并返回栈顶元素
char top = stack.pop();
//返回栈顶元素，但不移除它
char top = stack.peek();
//判断栈是否为空
boolean empty = stack.isEmpty();
//返回栈中元素的个数
int size = stack.size(); 

大顶堆 PriorityQueue, PriorityQueue

1.定义一个优先队列

//小顶堆，存储map元素，按value排序
PriorityQueue<Map.Entry<Integer, Integer>> minHeap = new PriorityQueue<>(
	(a, b) -> a.getValue() - b.getValue() //按频率升序排序（Lambda 表达式）
);
//堆中存储的是 int[] 类型的元素，每个元素是一个长度为 2 的数组
//pair[0] 存储数组 nums 中的值，pair[1] 存储该值在 nums 中的下标
//堆的比较规则是：首先按值从大到小排序（pair2[0] - pair1[0]），如果值相同，则按下标从大到小排序（pair2[1] - pair1[1]）
PriorityQueue<int[]> pq = new PriorityQueue<int[]>(new Comparator<int[]>() {
    public int compare(int[] pair1, int[] pair2) {
        return pair1[0] != pair2[0] ? pair2[0] - pair1[0] : pair2[1] - pair1[1];
    }
});

2.队列中加入，读取，移除元素

//将数组 nums 的前 k 个元素及其下标加入堆中
for (int i = 0; i < k; ++i) {
    pq.offer(new int[]{nums[i], i});
}
//读取堆顶元素的值
int ans = pq.peek()[0];
//移除堆顶元素
pq.poll();