通过我们适合初学者的数据结构指南（包含说明性示例）深入了解 Java 世界。
理解结构对于软件开发至关重要。Java是学习数据结构的理想选择，因为它的语法简单，应用范围广泛，从移动应用开发到大数据分析。
让我们仔细看看 Java 中的数据结构。
什么是数据结构？
数据结构描述了数据集的组织和管理方式。它定义了如何在编程语言中存储、访问和操作信息。了解数据元素之间的相关性可让Java 开发人员更有效地处理信息。
在 Java 中使用数据结构的好处
Java 开发需要高效的流程，利用数据结构可以帮助加快处理和检索速度。
高效内存使用
为项目选择正确的数据结构会影响性能，因为会影响内存使用。不同的数据结构以不同的方式使用内存。例如，链表数据结构由于其动态特性，可以使用任何可用内存，在添加元素时分配内存，而数组使用连续内存进行存储，需要特殊分配。
提高性能
了解适当的数据结构有助于缓解问题，并通过改善数据时间周期和空间复杂度来提供更好的结果。有些数据结构对于复杂的操作来说太简单了。例如，数组可以搜索一百万个整数，而 HashSet 可以提供更好的结果。了解如何以及何时应用每个数据结构可以节省时间和精力并提高性能。
增强数据管理
使用特定的数据结构有助于将多条数据集中在一个地方。其默认结构可确保更快、更准确地执行程序任务。它们通过增强可读性、发现错误和提高程序的生产力来改进应用程序。
支持复杂功能
树和图可以实现原始数据结构无法实现的复杂功能。它们提供了一种方法来呈现元素之间的建模关系，这种关系超越了具有单一值和有限范围的基本数据类型。树数据结构允许分层表示，子元素会分支出来，而图数据结构可以具有由覆盖广泛复杂网络的节点（顶点）组成的更通用的数据结构。
数据结构可重用性
数据结构可以在不同的元素或程序之间重复使用。环形缓冲区（循环队列）将队列的最后一个节点连接到第一个节点，从而实现重复使用数据。实施数据重用技术可消除重复访问相同数据的需要。
更好地解决问题
数据结构使程序员能够更好地了解问题的本质，从而有效地解决问题。作为通过对象关系进行问题建模的一个组成部分，它们可以帮助缓和框架内的潜在问题。
Java 中的数据结构类型
采用统一的数据系统方法意味着更好的性能。数据必须尽可能无缝地流动。
Java 适应性强。Sun Microsystems 的“一次编写，随处运行”（WORA）口号代表了一场编程革命。难怪 Java 是最常用的编程语言之一。
有一些结构特征需要考虑：
- 线性与非线性：序列结构，或数据集中项目的顺序
- 同质性与异质性：给定存储库内的组成特征
- 静态数据结构与动态数据结构：大小、结构和内存位置方面的变化
根据复杂性，数据集分类的方法有很多：原始、非原始和抽象。
原始数据结构
原始数据类型结构是存储原始数据的最简单方法。主要有四种类型：整数、字符、布尔值和浮点数。
由于它们的大小固定且格式简单，因此需要的内存很少，处理速度很快。这些基本值可以通过执行基本算术和基本逻辑运算进行交互。
整数
Java 中的整数 (int) 数据类型用于存储整数。它包括任何没有小数点的数字，例如 -42、0 和 8463。整数通常用于计算。它们对于对大型数据集进行排序和搜索也至关重要。
特点
字符数据类型 (char) 是一种表示单个字符的原始结构。它包括字母、符号和数字，通常用单引号表示，可用于存储单个单词或文本字符串。char 数据类型通常用于识别用户输入值和编写在屏幕上显示消息的程序。
布尔值
此数据类型以布尔代数命名，具有两个值：false (0) 和 true (1)。它可以在逻辑控制结构中找到。二进制数据类型可以在编程中构成相反的值（是/否；开/关；真/假等）。Java 仅将 boolean 关键字用作原始数据类型，因为它仅存储两个可能的值，并且经常用于条件测试和类似操作。
浮点
Java 中的浮点数据类型是更精确的原始数据结构，可以存储精度高达七位的十进制值。带有小数部分的数值存储为尾数（二进制数字）和指数（基数乘以自身的次数）。浮点结构已用于数据科学工程、经济等领域。
非原始数据结构
这些数据集也称为引用数据结构，它们比原始类型更复杂，因为它们引用的对象不是预先确定的。程序员会创建非原始数据类型，但 String 除外。
大批
数组数据结构是一种非原始数据结构，它按顺序存储元素集合，其中可以使用其索引（数组中的元素位置）访问每个元素。它们通常用于存储相关对象或值的列表，例如学生成绩或员工姓名。
要在 Java 中创建数组，首先必须指明元素的数据类型，后跟方括号 [ ]。然后，需要指定数组的大小。
// 声明并初始化整数数组
int[] myArray = new int[5];
// 字符串数组的声明和初始化
String[] 名称 = new String[3];Java 中的数组操作
数组通过分配连续的内存来确保高效的存储，其中元素可以使用其索引直接访问。使用 lops 轻松遍历使对每个元素执行操作变得简单。
- 插入会向数组中添加一个元素，该元素将移动数组所有其他元素以腾出空间。
要将元素插入数组，可以为特定索引分配一个值。
int[] numbers = new int[5]; // 声明一个大小为 5 的整数数组
numbers[0] = 10; // 为第一个元素分配一个值
numbers[1] = 20; // 为第二个元素赋值
numbers[2] = 30; // 为第三个元素赋值
// 在索引 1 处插入新元素
numbers[1] = 15; // 先前的值（20）被覆盖- 删除操作会从索引中移除一个元素，并且需要移动数组中的所有其他元素以填充被删除元素留下的空间。为特定索引分配一个默认值或空值。
String[] names = new String[3]; // 声明一个大小为 3 的字符串数组
names[0] = “爱丽丝”;
names[1] = “鲍勃”;
names[2] = "查理";
// 删除索引 1 处的元素
names[1] = null;- 可以使用 for 循环或 forEach 循环来遍历数组。
public class ArrayTraversalExample {
public static void main(String[] args) {
// 创建一个包含一些值的数组
int[] numbers = {10, 20, 30, 40, 50};
// 使用 for 循环遍历
System.out.println("使用 for 循环遍历：");
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
// 使用 forEach 循环遍历
System.out.println("\n使用 forEach 循环遍历：");
for (int num : numbers) {
System.out.println(num);
}
}
}使用以下两种方法遍历值 10-50 的“数字”数组：
- 使用变量“i”的“for”循环，其中每个元素都使用“number[1]”访问
- forEach 循环未使用表示数组中每个元素的变量 ‘num’ 明确管理索引
使用 for 循环遍历：
10
20
30
40
50
使用 forEach 循环遍历：
10
20
30
40
50链表
Java LinkedList 数据类由包含从一个节点到另一个节点的数据引用的顺序节点组成。在容器中存储的列表中添加或删除元素时，其大小会发生变化。与数组相比，它们不需要连续的内存分配，允许在运行时动态分配内存。
在 Java 中实现 LinkedList 需要定义一个包含数据和对下一个节点的引用的 Node 类：
class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
}
}LinkedLists 在需要动态大小、频繁插入和删除以及灵活内存分配的场景中表现出色，但可能不适合需要随机访问或有严格内存限制的情况。
LinkedLists 的优点包括：
- 在运行时动态地增大或缩小可以实现高效的内存利用率和灵活地管理不断变化的数据大小。
- 更容易频繁的插入和删除操作可以不断地进行。
- 由于每个节点都会分配内存并且不需要连续的内存块，因此内存利用和分配具有灵活性。
LinkedLists 有其优点，但无法通过索引访问元素。额外的内存用于存储对下一个节点的引用。反向遍历或随机访问元素效率低下，并且管理节点引用和链接很复杂。
Java 中的 LinkedList 操作
LinkedList 操作对于频繁插入和删除元素的操作是一个很好的解决方案，通过以下方式：
- 插入
- 删除
- 和遍历。
插入
Java 中的 LinkedList 插入可以使用add() 方法完成。例如：
import java.util.LinkedList;
public class LinkedListInsertionExample {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
// 使用 add() 方法插入元素
list.add("apple");
list.add("banana");
list.add("cherry");
// 打印 LinkedList
System.out.println("插入后的 LinkedList: " + list);
}
}删除
要删除头节点，请调整前一个和后一个节点指针以绕过它，并将对下一个节点的引用设置为新的头节点。
import java.util.LinkedList;
public class LinkedListDeletionExample {
public static void main(String[] args) {
LinkedList<Integer> numbers = new LinkedList<>();
// 向 LinkedList 添加元素
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(40);
// 使用 remove() 删除特定元素
numbers.remove(Integer.valueOf(30));
// 打印修改后的 LinkedList
System.out.println(numbers); // 输出：[10, 20, 40]
}
}在上面的例子中，我们创建一个名为“numbers”的 LinkedList，并向其中添加一些元素。然后我们使用 `remove()` 方法删除值为 '30' 的元素。最后，我们打印包含 [10, 20, 40] 的修改后的列表。
遍历
Java 中的 LinkedList 遍历涉及访问 LinkedList 中的每个节点并对其执行操作。
import java.util.LinkedList;
public class LinkedListTraversalExample {
public static void main(String[] args) {
// 创建链表 LinkedList
<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(4);
linkedList.add(5);
// 遍历链表
for (Integer element : linkedList) {
System.out.print(element + " ");
}
}
}堆栈和队列
堆栈和队列是许多编程语言中使用的两个最基本的例子。
堆栈
堆栈数据结构的一种常见视觉呈现是一叠盘子，只能从顶部进行更改。这称为后进先出数据结构，其中最后(推送) 添加的元素是第一个被移除 (弹出) 的元素。
push方法将项目添加到堆栈中。
import java.util.Stack;
Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);pop方法从堆栈中删除项目。
int poppedElement = stack.pop(); // 返回 30
队列
队列是类似于堆栈的线性数据结构，但两端都是开放的。除了元素移除之外，它们遵循 FIFO 原则。在队列中，最旧的元素首先通过入队和出队被移除。
enqueue方法将元素添加到队列的后端。
import java.util.LinkedList;
import java.util.Queue;
Queue<String> queue = new LinkedList<>();
queue.add("Alice");
queue.add("Bob");
queue.add("Charlie");dequeue方法从队列中移除并返回最新/第一个元素。
String dequeuedElement =queue.poll(); // 返回“Alice”
通过使用这些操作，您可以根据特定的排序规则操作堆栈和队列中的元素，并有效地执行各种任务。
树木
树是非线性数据结构，以分层方式存储信息。它们由具有数据值的节点和对其他节点（或子树）的引用组成。树通常用于排序和搜索操作、存储和遍历分层数据。
Java中二叉树实现的示例：
public class BinaryTree {
private TreeNode root;
// 创建树
public void create(int[] arr) {
this.root = new TreeNode(arr[0]);
Queuequeue = new LinkedList<>();
queue.add(root);
int i = 1;
while (I < arr.length) {
TreeNode currentNode =queue.remove();
if (arr[i] != -1) {
currentNode.Java中的树操作
树是编程中必不可少的数据结构。树上可以执行的主要操作包括插入、删除、搜索和遍历。
插入
在二叉搜索树中添加新元素时，应以不违反每个值的方式进行设计。示例：
10
/ \
5 15
我们可以插入值 12，如下所示：
10
/ \
5 15
/ \ / \
3 7 12 18
删除
在二叉树中删除一个节点需要用它的后继节点或前任节点（以先可用的为准）替换被删除的节点。
例如，给定上面的树，如果我们想删除 10，我们可以用其按序后继 12 替换它，如下所示：
12
/ \
5 15
/ \ / \
3 7 10 18
搜索
二叉搜索树提供了高效的搜索功能，因为每个分支只有两个选项，并且每次向左或向右移动都会将需要搜索的节点数量减少一半。例如，给定我们的原始二叉树，我们可以按如下方式搜索 7：
10
/ \
5 15
/ \ / \
3 7 12 18
遍历
图遍历可确保树数据结构中的所有节点仅被访问一次。遍历有三种类型：
- 前序遍历首先访问根，然后再移动到子树。
- 后序遍历从子树移动到根开始。
- 中序遍历从左孩子（和整个子树）开始，移动到根，并以访问右孩子结束。
例如，给定原始二叉树，我们可以按如下顺序遍历：3->5->7->10->12->15->18
图表
图形是呈现非线性数据的常用方式。它由顶点、图形单元（顶点或节点）和边（节点之间的连接路径）组成。
添加顶点
在图结构中实现一个新节点需要添加一个新对象。
import java.util.ArrayList;
import java.util.List;
public class Graph {
private int numVertices;
private List<List<Integer>> adjacencyList;
public Graph(int numVertices) {
this.numVertices = numVertices;
adjacencyList = new ArrayList<>(numVertices);
// Initialize the adjacency list
for (int i = 0; i < numVertices; i++) {
adjacencyList.add(new ArrayList<>());
}
}
public void addVertex() {
numVertices++;
adjacencyList.add(new ArrayList<>());
}
}添加边
找到要连接的两个顶点后，在添加边之前在它们之间设置必要的参考。
import java.util.ArrayList;
import java.util.List;
public class Graph {
private int numVertices;
private List<List<Integer>> adjacencyList;
public Graph(int numVertices) {
this.numVertices = numVertices;
adjacencyList = new ArrayList<>(numVertices);
// 初始化邻接表
for (int i = 0; i < numVertices; i++) {
adjacencyList.add(new ArrayList<>());
}
}
public void addEdge(int source, int destination) {
// 检查顶点是否在有效范围内
if (source >= 0 && source < numVertices && destination >= 0 && destination < numVertices) {
// 将目标顶点添加到源顶点的邻接表中
adjacencyList.get(source).add(destination);
// 如果图是无向的，则将源顶点也添加到目标顶点的邻接列表中
// adjacencyList.get(destination).add(source); // 对于无向图，取消注释此行
}
}
}图的遍历
当访问每个顶点进行检查或更新时，将执行图搜索。根据问题的类型，可以进行两次迭代来执行此操作。
广度优先遍历 (BFS)通常以队列数据结构实现。它从给定节点（通常是根节点）开始，探索其相邻节点，然后移动到下一级节点，直到访问完所有节点。BFS 通常使用队列数据结构实现。
import java.util.LinkedList;
import java.util.Queue;
class Graph {
private int numVertices;
private LinkedList<Integer>[] adjacencyList;
public Graph(int numVertices) {
this.numVertices = numVertices;
adjacencyList = new LinkedList[numVertices];
for (int i = 0; i < numVertices; i++) {
adjacencyList[i] = new LinkedList<>();
}
}
public void addEdge(int source, int destination) {
adjacencyList[source].add(destination);
}
public void breadthFirstTraversal(int startVertex) {
boolean[] visited = new boolean[numVertices];
Queue<Integer> queue = new LinkedList<>();
visited[startVertex] = true;
queue.offer(startVertex);
while (!queue.isEmpty()) {
int currentVertex = queue.poll();
System.out.print(currentVertex + " ");
for (int neighbor : adjacencyList[currentVertex]) {
if (!visited[neighbor]) {
visited[neighbor] = true;
queue.offer(neighbor);
}
}
}
}
}
public class Main {
public static void main(String[] args) {
Graph graph = new Graph(6);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 3);
graph.addEdge(2, 4);
graph.addEdge(3, 4);
graph.addEdge(3, 5);
System.out.println("Breadth-First Traversal:");
graph.breadthFirstTraversal(0);
}
}深度优先遍历 (DFS) 使用递归或堆栈数据结构探索图形，尽可能沿着每个分支走得更远，然后再回溯。它从给定节点（通常是根）开始，尽可能深入地探索，然后再回溯并访问其他相邻节点。
import java.util.LinkedList;
class Graph {
private int numVertices;
private LinkedList<Integer>[] adjacencyList;
public Graph(int numVertices) {
this.numVertices = numVertices;
adjacencyList = new LinkedList[numVertices];
for (int i = 0; i < numVertices; i++) {
adjacencyList[i] = new LinkedList<>();
}
}
public void addEdge(int source, int destination) {
adjacencyList[source].add(destination);
}
public void depthFirstTraversal(int startVertex) {
boolean[] visited = new boolean[numVertices];
dfsHelper(startVertex, visited);
}
private void dfsHelper(int vertex, boolean[] visited) {
visited[vertex] = true;
System.out.print(vertex + " ");
for (int neighbor : adjacencyList[vertex]) {
if (!visited[neighbor]) {
dfsHelper(neighbor, visited);
}
}
}
}
public class Main {
public static void main(String[] args) {
Graph graph = new Graph(6);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 3);
graph.addEdge(2, 4);
graph.addEdge(3, 4);
graph.addEdge(3, 5);
System.out.println("Depth-First Traversal:");
graph.depthFirstTraversal(0);
}
}这两种遍历方法在图算法和应用中都发挥着重要作用，例如查找连通分量、检测循环、确定可达性以及解决基于图的难题。
抽象数据类型
抽象数据类型( ADT) 是附加数据结构的基础，不会影响实现过程。抽象数据类型可分为
- 内置/用户定义
- 可变/不可变
在 Java 中，抽象类由特定数据结构的接口契约定义。
List
Java 集合框架的一部分是为数组和链表实现而构建的。
列表接口创建一个 ArrayList 来存储名称：
import java.util.ArrayList;
import java.util.List;
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
System.out.println(names.get(1)); // Output: "Bob"Set
Java中的AbstractSet类为实现集合接口和抽象集合类的set接口提供了主体框架，与list接口不同，不允许元素重复，提供了add、remove、contain、size等方法。
使用set接口存储一组数字：
import java.util.HashSet;
import java.util.Set;
Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(2); // 重复元素，未添加
System.out.println(numbers.contains(2)); // 输出：trueMap
Java 中的 map 接口以具有唯一键的键值对形式存储数据。它提供 put、get、remove 和 containsKey 等方法。它通常用于键值对存储。以下是使用 map 接口存储姓名和年龄映射的示例：
import java.util.HashMap;
import java.util.Map;
Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 25);
ages.put("Bob", 30);
ages.put("Charlie", 35);
System.out.println(ages.get("Bob")); // Output: 30如何在 Java 中选择正确的数据结构
决定哪种数据结构最适合任何程序实现，很大程度上取决于输入、数据处理和输出操作等因素。
根据操作的复杂性和性能预期，程序员可以缩小具有类似输出的潜在结构范围。最好从最简单的解决方案开始，然后逐步完成。
考虑所选数据结构的易用性和维护性。某些数据结构具有复杂的实现细节或需要特定的编码实践。利用现有的 Java 集合，并使用具有优化性能和功能的预实现结构。
结论
为程序实现选择最合适的数据结构需要彻底了解程序要求，仔细分析所涉及的操作，并考虑内存效率、搜索能力和排序要求等各种因素。
数据结构应具有一系列预定义的操作和属性，以确保软件性能的平稳运行。数据结构在 Java 中至关重要，并且数据生成不断增长。
