工欲善其事必先利其器。虽然算法本身是不区分语言的，但是作为专注于Java开发的唐叔，那么善于使用Java自带的已实现的数据结构，将有利于在更短的时间内快速通关具体的算法题。
而今天我们就来学习Java中的数据结构实现。善用这些API将有助于我们更有效地存储和处理数据。
数组（Array）
线性数据结构，通过连续内存空间存储元素。
特点：支持索引快速访问，但是插入和删除操作慢，且大小固定，存储同类型元素。
「示例代码：」
// 声明数组并填充数据
int[] data = new int[5];
Arrays.fill(data, 0);
for (int number : data) {
System.out.print(number + " ");
}
// 声明数组并赋值
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
System.out.print(number + " ");
}
栈（Stack）
栈是一种后进先出（LIFO）的线性表数据结构，只允许在表一端(栈顶)进行插入和删除操作。
适用于需要按照特定顺序访问元素的场景，如函数调用栈。
Java中的Stack类提供了栈的基本操作
「示例代码：」
Stack<Integer> stack = new Stack<>();
// 入栈
System.out.println(stack.push(1));
System.out.println(stack.push(2));
// 出栈
System.out.println(stack.pop());
// 查看栈顶元素
System.out.println(stack.peek());
// 出栈
System.out.println(stack.pop());
队列（Queue）
队列是一种先进先出（FIFO）的线性表数据结构，允许一端(队尾)插入元素，另一端(队头)删除元素。
适用于按序处理元素场景，如消息队列、任务调度。
Java中的Queue接口和LinkedList类常用来实现队列。
「示例代码：」
Queue<Integer> queue = new LinkedList<>();
// 入队
queue.offer(1);
queue.offer(2);
// 出队
System.out.println(queue.poll());
// 查看队首元素
System.out.println(queue.peek());
System.out.println(queue.poll());
链表（LinkedList）
链表由节点组成，每个节点包含数据和指向下一个节点的指针。
适用于频繁插入和删除操作的场景。
Java中的LinkedList类实现了链表。
「示例代码：」
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
// 在链表头部添加
linkedList.addFirst(0);
// 在链表尾部添加
linkedList.addLast(0);
// 输出 [0, 1, 2, 0]
System.out.println(linkedList);
树（Tree）
树是非线性数据结构，由节点组成，每个节点含零个或多个子节点。
适用于需要快速查找、插入和删除元素的场景。
Java语言中确实有类似树这种数据结构的实现，最常用的是java.util包中的TreeMap和TreeSet类，它们基于红黑树实现。此外，Java标准库中没有直接提供通用的树结构实现，但我们可以使用java.util包中的AbstractMap和AbstractSet等抽象类来自定义树结构。
「使用TreeMap和TreeSet」
TreeMap和TreeSet都是基于红黑树实现的，它们可以自动保持元素的排序。
「TreeMap示例代码：」
import java.util.Map;
import java.util.TreeMap;
public class TreeMapExample {
public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(1, "Apple");
treeMap.put(3, "Carrot");
treeMap.put(2, "Banana");
System.out.println("Keys in ascending order:");
for (Integer key : treeMap.keySet()) {
System.out.println(key);
}
System.out.println("\nValues in ascending order:");
for (String value : treeMap.values()) {
System.out.println(value);
}
}
}
「TreeSet示例代码：」
import java.util.Set;
import java.util.TreeSet;
public class TreeSetExample {
public static void main(String[] args) {
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println("Elements in ascending order:");
for (Integer number : treeSet) {
System.out.println(number);
}
}
}
「基于Java的树的实现示例」
如果你需要一个更通用的树结构，可以自己实现。下面是一个简单的二叉树实现及其常用操作的示例。
「二叉树节点类：」
class TreeNode {
int value;
TreeNode left;
TreeNode right;
public TreeNode(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
「二叉树类及其常用操作：」
class BinaryTree {
TreeNode root;
public BinaryTree() {
root = null;
}
// 插入节点
public void insert(int value) {
root = insertRec(root, value);
}
private TreeNode insertRec(TreeNode root, int value) {
if (root == null) {
root = new TreeNode(value);
return root;
}
if (value < root.value) {
root.left = insertRec(root.left, value);
} else if (value > root.value) {
root.right = insertRec(root.right, value);
}
return root;
}
// 二叉树遍历
public void inorderTraversal() {
inorderRec(root);
}
private void inorderRec(TreeNode root) {
if (root != null) {
inorderRec(root.left);
System.out.print(root.value + " ");
inorderRec(root.right);
}
}
public static void main(String[] args) {
BinaryTree tree = new BinaryTree();
tree.insert(7);
tree.insert(3);
tree.insert(9);
tree.insert(1);
tree.insert(5);
tree.insert(10);
System.out.println("Inorder Traversal of the binary tree:");
tree.inorderTraversal(); // 输出应该是一个排序好的序列
}
}
基于上述，我们实现了一个简单的二叉搜索树，它允许我们插入新节点，并进行中序遍历，输出一个排序好的序列。这只是树的一种实现，根据需要，你可以扩展更多的功能，如删除节点、查找节点、前序遍历和后序遍历等。
图（Graph）
用于表示实体及其之间关系的数据结构，由节点和边组成。有有向图和无向图。
适用于表示复杂的数据关系和路径，如社交网络、交通网络等。
Java没有内置的图数据结构，以下是两种参考实现。
- 邻接矩阵实现：邻接矩阵是一个二维数组，其中graph[i][j]表示顶点i到顶点j的边的信息。如果i和j之间没有边，则graph[i][j]通常为0；如果有边，则可以存储边的权重等信息。
「示例代码（邻接矩阵实现）」
public class GraphMatrix {
private int[][] graph;
private int numVertices;
public GraphMatrix(int vertices) {
numVertices = vertices;
graph = new int[vertices][vertices];
}
public void addEdge(int start, int end, int weight) {
graph[start][end] = weight;
// 如果是无向图，也需要添加下面的代码
// graph[end][start] = weight;
}
public void printGraph() {
for (int i = 0; i < numVertices; i++) {
for (int j = 0; j < numVertices; j++) {
if (graph[i][j] != 0) {
System.out.print(graph[i][j] + " ");
} else {
System.out.print("0 ");
}
}
System.out.println();
}
}
public static void main(String[] args) {
GraphMatrix graph = new GraphMatrix(4);
graph.addEdge(0, 1, 1);
graph.addEdge(0, 2, 2);
graph.addEdge(1, 2, 1);
graph.addEdge(1, 3, 3);
graph.printGraph();
}
}
- 邻接表实现：邻接表使用一个列表来表示图，其中外层列表的每个元素是一个链表，表示一个顶点，内层链表的每个节点包含相邻顶点的信息。
「示例代码（邻接表实现）：」
import java.util.ArrayList;
import java.util.List;
public class GraphList {
private List<List<Integer>> adjList;
private int numVertices;
public GraphList(int vertices) {
numVertices = vertices;
adjList = new ArrayList<>();
for (int i = 0; i < vertices; i++) {
adjList.add(new ArrayList<>());
}
}
public void addEdge(int start, int end) {
adjList.get(start).add(end);
// 如果是无向图，也需要添加下面的代码
// adjList.get(end).add(start);
}
public void printGraph() {
for (int i = 0; i < numVertices; i++) {
System.out.print("Vertex " + i + ":");
for (Integer neighbor : adjList.get(i)) {
System.out.print(" -> " + neighbor);
}
System.out.println();
}
}
public static void main(String[] args) {
GraphList graph = new GraphList(4);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(1, 3);
graph.printGraph();
}
}
堆（Heap）
Java中的PriorityQueue类实现了堆结构，可以快速访问最大或最小元素。
「示例代码：」
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
maxHeap.offer(10);
maxHeap.offer(5);
maxHeap.offer(20);
System.out.println(maxHeap.poll()); // 输出 20
散列表（HashMap）
Java中的HashMap类基于散列表实现，提供了快速的键值对存储和访问。
「示例代码：」
HashMap<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
System.out.println(map.get("Alice")); // 输出 25
通过这篇文章，我们学习了Java中各种数据结构的实现和基本用法。选择合适的数据结构可以显著提高程序的性能和可读性，也有利于在做算法题时，快速通关算法。
