掌握数据结构基本用法，这篇文章就够了（Java、C++和Python）

本文对Java、c++以及Python中常用到的一些数据结构及其方法做了一个汇总，方便查阅。

数组（列表）

// Java
import java.lang.Arrays;
int[] arr1 = new int[10];	// int默认为0
int[] arr2 = new int[]{1, 2, 3, 4};		// 直接初始化
Arrays.fill(arr1, -1);		// 将arr1数组初始化为-1
arr1[1] = 10;	
System.out.println(arr1[1]);		// 10
System.out.println(arr2[1]);		// 2
Arrays.stream(arr2).sum();			// 10
Arrays.stream(arr2).max();			// 4
Arrays.stream(arr2).min();			// 1

// 补充几个常用stream
List<Integer> list1 = Arrays.stream(arr1).boxed().collect(Collectors.toList());		//数组->列表
List<Integer> list2 = Arrays.asList(1, 2);	// 数组->列表
points = points.stream().distinct().collect(Collectors.toList());	// 列表去重

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
List<Integer> list1 = new ArrayList<>();	// 数组形式
List<Integer> list2 = new LinkedList<>();	// 链表形式

// 常用的方法：
list1.add(10);	
list2.add(20);
list1.addAll(list2);
list1.get(1);	// 获取指定下标对应的值，20
list1.isEmpty();	// 判断是否为空，false
list1.contains(10);	// 判断是否包含，true

// C++
int arr1[10];
int n = 5;
int arr2[n];	// 当数组长度为变量时，需要用memset来初始化数组
memset(arr2, 0, sizeof(arr2));		// 初始化为0，需要导入头文件<cstring>
arr1[1] = 10;
cout<<arr1[1]<<endl;	// 10
cout<<arr2[1]<<endl;	// 0

// 向量，底层仍是数组 
#include <vector>
vector<int> vec1(10, 5);	// 初始化为5
vector<vector<int>> vec2(10, vector<int>(20));	// 二维数组
cout<<accumulate(vec1.begin(), vec2.end(), 0);	// 第三个参数意思是初始值为0
max_element(vec1.begin(), vec1.end());			// 返回最大元素
vec1.emplace_back();	// 添加
vec1.push_back();		// 也是添加
vec1.pop_back(); 		// 删除最后一个
vec[2] = 5;				// 替换

# Python
arr1 = [0] * 10	 	
max(arr1)	# 最大值
min(arr1) 	# 最小值
sum(arr1)	# 数组求和
len(arr1)	# 数组长度
arr1.reverse()	# 数组翻转

arr2 = list()
arr2.append()	# 添加
arr2.pop() 		# 删除最后一个元素
print(arr2[:])	# 输出列表
arr3 = [2, 3, 4]
arr2.extend(arr3)	# 一次添加多个值

集合（无重复）

// Java	
import java.util.Set;
import java.util.HashSet;
Set<Integer> set = new HashSet<>();
set.add();		// 添加
set.remove();	// 移除
set.contains();	 // 是否包含
set.size();		// 集合大小
for (Integer i : set) {		// 迭代
	System.out.println(i);
}

// C++
#include <set>
unordered_set<int> set;
set<int> set;		//有序，可以使用begin()获取迭代器
set.insert();			// 添加
set.count();			// 判断是否包含
set.erase();			// 删除

# Python
set = set()
set.add()		# 添加
set.discard()	# 删除
n in set		# 判断n是否在set中

队列

// Java	
import java.util.Deque;
import java.util.ArrayDeque;
Deque<Integer> queue = new ArrayDeque<>();
queue.addFirst();		// 头部添加
queue.addLast();		// 尾部添加
queue.removeFirst();		// 头部移除
queue.removeLast();		// 尾部移除

queue.put();	
queue.poll();	
queue.peek();

// 优先队列（堆）
import java.util.PriorityQueue;
PriorityQueue<Integer> queue = new PriorityQueue<Integer>();
queue.add();
queue.contains();
queue.peek();
queue.poll();

// C++
#include <queue>
queue<int> set;
queue.push();			// 入队
queue.pop();			// 出队
queue.back();			// 返回最后入队的值
queue.front();		// 返回最先出队的值
queue.empty();		// 队列是否为空
queue.size();		// 队列大小

// 优先队列，也在<queue>头文件中, greater和less需要头文件#include <functional>
#include <queue>
#include <functional>
priority_queue<int, vector<int>, greater<int>> pq;		// 升序，小顶堆（默认）
priority_queue<int, vector<int>, less<int>> pq;		// 降序，大顶堆
pq.push();
pq.front();
pq.pop();

# Python
import collections
q = deque()
q.append()
q[]		# 队首元素
q.popleft()		# 出队

# 优先队列
import heapq
heap = []
heapq.heappush(heap, [5, 7])	# 入堆
heapq.heappop(heap)				# 出堆，默认小根堆，若实现大根堆如入堆前加负号
heapq.heapreplace(heap, new)	# 删除对顶元素，将新值放入堆顶再重新排序

栈

// Java	
import java.util.Deque;
import java.util.LinkedList;
Deque<Integer> stack = new LinkedList<>();
stack.addFirst();		// 头部添加
stack.addLast();		// 尾部添加
stack.removeFirst();	// 头部移除
stack.removeLast();		// 尾部移除

stack.push();	
stack.pop();	
stack.peek();

// C++
#include <stack>
stack<int> stack;
stack.push();			// 入栈
stack.emplace();		// 入栈
stack.pop();			// 出栈
stack.top();			// 返回栈顶元素
queue.empty();		// 栈是否为空
queue.size();		// 栈大小

# Python
stack = []
stack.append()		# 入栈
stack.pop()			# 出栈
stack[-1]				# 栈顶元素

哈希映射

// Java	
import java.util.Map;
import java.util.HashMap;
Map<Integer, Integer> hm = new HashMap<>();
hm.put(1, 5);			// 添加，也可用于替换
hm.get(1);				// 查询 
hm.getOrDefault(2, 0);	// 查询，无该值返回默认值
hm.remove(1);			// 移除
hm.size();				// 大小

// 输出 key 和 value
for (Integer i : hm.keySet()) {
    System.out.println("key: " + i + " value: " + hm.get(i));
}
// 返回所有 value 值
for(Integer value: hm.values()) {
  // 输出每一个value
  System.out.print(value + ", ");
}

// 迭代
import java.util.Map.Entry;
// entrySet()返回了 HashMap 中所有映射项的一个 set 集合视图
// for-each loop 在该视图中访问了每一映射项
for(Entry<Integer, Integer> entry: numbers.entrySet()) {
     System.out.print(entry);	
     System.out.print(", ");		
}

// C++
#include <map>
map<int, int> hm;
hm[1] = 5;				// 添加，也可用于替换
hm[1];					// 查询 
hm.find();				// 查询，返回迭代器，如果=hm.end(),即没找到
hm.erase(1);			// 移除
hm.count();				// 判断是否包含

// 遍历
for(auto &[key, value]: hm) {
	cout<<key<<value<<endl;
}
for(auto iter = hm.begin(); iter != hm.end(); ++iter){
	cout<<iter->first<<iter->second<<endl;
}
for(auto iter : hm){
	cout<<iter.first<<iter.second<<endl;
}

# Python
import collections
from sortedcontainers import SortedDict

hm = dict()
hm1 = collections.defaultdict(int)		# 默认返回工厂函数的值 int对应0
hm[1] = 5;				# 添加，也可用于替换
hm[1];					# 查询 
hm.get(2, 0);			# 查询，可以返回默认值
del hm[1];				# 移除
5 not in hm;			# 判断是否包含
hm.clear()				# 清除

hm2 = SortedDict()		# 有序集合

# 如果是计数，可以使用
hm = Counter()
hm[x] += 1		# 计数+1
mx = max(hm.values())		# 返回计数最大的计数值

# 遍历
for k, v in hm.items():

目前主要的数据结构及方法已经总结完毕，之后还有重要内容会持续更新。也可以看我的其他文章获取更多内容。