Java 复习笔记 - 集合进阶篇：数据结构
文章目录
- 数据结构 概述
- 常见的数据结构
- 示例
-
- （一）数组（Array）
- （二）链表（LinkedList）
- （三）栈（Stack）
- （四）队列（Queue）
- （五）集合（Set）
- （六）映射（Map）
- （七）树（Tree）
- （八）图（Graph）
数据结构 概述
数据结构是一种组织和存储数据的方式，它描述了数据元素之间的相互关系以及数据元素的组织形式。数据结构基本概念包括数据、数据元素和数据项、数据对象、数据结构、逻辑结构和存储结构。数据是指能够被计算机识别、存储、计算（处理）的符号集合，而数据元素也称作节点，是数据的基本单位，最小单位是数据项。数据对象是具有相同特征的数据元素的集合，是数据的子集。
数据结构是计算机存储、组织数据的方式，它分为数据的逻辑结构和存储结构。逻辑结构是指从逻辑关系上描述数据，与数据的存储无关，且独立于语言。存储结构是指数据元素及其关系在计算机存储时如何表示，依赖于语言。根据数据的逻辑关系，可以将数据结构分为线性结构和非线性结构。线性结构包括集合结构、线性结构和双线性结构，这些结构中的元素存在一对一的相互关系。而非线性结构包括树形结构和图形结构，这些结构中的元素存在一对多或多对多的相互关系。
总之，数据结构是计算机中用于管理和处理数据的一种方法，它有助于提高数据处理效率和精度。
常见的数据结构
Java 中常见的数据结构主要有以下几种：
- 数组（Array）：数组是一种线性表数据结构，可以存储同一类型的元素集合。在 Java 中，数组可以通过声明和初始化来创建。
- 链表（LinkedList）：链表是一种线性表数据结构，可以存储不同类型的元素集合。在 Java 中，链表可以通过
LinkedList类来实现。 - 栈（Stack）：栈是一种后进先出（LIFO）的数据结构，可以存储不同类型的元素集合。在 Java 中，栈可以通过
Stack类来实现。 - 队列（Queue）：队列是一种先进先出（FIFO）的数据结构，可以存储不同类型的元素集合。在 Java 中，队列可以通过
Queue接口和它的实现类（如LinkedList）来实现。 - 集合（Set）：集合是一种不允许重复元素的数据结构，可以存储不同类型的元素集合。在 Java 中，集合可以通过
Set接口和它的实现类（如HashSet）来实现。 - 映射（Map）：映射是一种键值对（key-value pair）的数据结构，可以存储不同类型的元素集合。在 Java 中，映射可以通过
Map接口和它的实现类（如HashMap）来实现。 - 树（Tree）：树是一种非线性的数据结构，可以存储不同类型的元素集合。在 Java 中，树可以通过
Tree接口和它的实现类（如BinaryTree）来实现。 - 图（Graph）：图是一种非线性的数据结构，可以存储不同类型的元素集合。在 Java 中，图可以通过
Graph接口和它的实现类（如SimpleGraph）来实现。
示例
（一）数组（Array）
在Java中，数组是一种简单的数据结构，用于存储固定大小的相同类型的元素集合。以下是一个Java数组的示例：
public class ArrayExample {
public static void main(String[] args) {
// 声明一个包含5个整数的数组
int[] numbers = new int[5];
// 通过索引访问和修改数组元素
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;
// 打印数组中的元素
for (int i = 0; i < numbers.length; i++) {
System.out.println("Element at index " + i + " : " + numbers[i]);
}
// 声明并初始化一个字符串数组
String[] words = {"Hello", "World", "Java", "Array", "Example"};
// 使用增强for循环打印数组中的元素
for (String word : words) {
System.out.println(word);
}
}
}
在这个例子中，我们首先声明了一个包含5个整数的数组numbers，然后通过索引访问和修改数组中的元素。接下来，我们使用一个for循环遍历数组并打印出每个元素。然后我们声明并初始化了一个字符串数组words，并使用增强for循环打印出数组中的元素。
（二）链表（LinkedList）
在Java中，链表是一种常见的数据结构，它是一系列节点的集合，每个节点包含两个部分：数据和指向下一个节点的引用。下面是一个简单的单向链表的示例：
public class LinkedList {
// 链表节点类
private static class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
}
}
// 头节点
private Node head;
// 向链表添加节点
public void add(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
Node current = head;
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
}
// 打印链表
public void printList() {
Node current = head;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.println();
}
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add(4);
linkedList.add(5);
linkedList.printList(); // 输出：1 2 3 4 5
}
}
上面的示例代码定义了一个简单的链表类LinkedList。它包含一个内部类Node，用于表示链表中的节点。每个节点包含一个整数值和一个指向下一个节点的引用。链表类有一个头节点head，它指向链表的第一个节点。add方法用于向链表末尾添加新节点，而printList方法用于打印链表的内容。main方法创建了一个LinkedList对象，向其添加了几个节点，然后打印出链表的内容。
（三）栈（Stack）
在Java中，栈是一种数据结构，它遵循LIFO（后进先出）原则。这意味着最后一个被添加到栈中的元素将是第一个被移除的元素。Java的java.util.Stack类提供了栈的实现。
以下是一个简单的Java程序，它演示了如何使用Stack类：
import java.util.Stack;
public class StackExample {
public static void main(String[] args) {
// 创建一个新的Stack实例
Stack<Integer> stack = new Stack<>();
// 使用push方法向栈中添加元素
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println("当前栈: " + stack);
// 使用peek方法查看栈顶元素，不移除
int top = stack.peek();
System.out.println("栈顶元素: " + top);
System.out.println("执行peek操作后的栈: " + stack);
// 使用pop方法移除栈顶元素
top = stack.pop();
System.out.println("被移除的元素: " + top);
System.out.println("执行pop操作后的栈: " + stack);
// 使用isEmpty方法检查栈是否为空
boolean empty = stack.isEmpty();
System.out.println("栈是否为空: " + empty);
}
}
这个示例展示了如何使用push方法将元素添加到栈中，使用peek方法查看（但不移除）栈顶元素，使用pop方法移除栈顶元素，以及使用isEmpty方法检查栈是否为空。
（四）队列（Queue）
在Java中，队列（Queue）是一种特殊类型的线性表，新元素总是在队列的末端添加，而删除操作总是在队列的开始进行。这样，队列中的元素总是先进先出（FIFO）。
下面是一个简单的Java程序，演示了如何使用Java的内置Queue接口以及它的实现类LinkedList：
import java.util.LinkedList;
import java.util.Queue;
public class QueueExample {
public static void main(String[] args) {
// 创建一个队列
Queue<Integer> queue = new LinkedList<>();
// 添加元素到队列
for (int i = 1; i <= 5; i++) {
queue.add(i);
}
// 显示队列的元素
System.out.println("Elements in queue: " + queue);
// 删除队列的头元素
int removedElement = queue.remove();
System.out.println("Removed element: " + removedElement);
// 查看队列的头元素，但不删除
int headElement = queue.peek();
System.out.println("Head of queue: " + headElement);
// 查看队列的大小
int size = queue.size();
System.out.println("Size of queue: " + size);
}
}
在这个示例中，我们创建了一个整数类型的队列，并使用LinkedList实现。我们添加了一些元素，并显示了队列的内容。然后我们删除了队列的头元素，并再次显示了队列的内容。我们还查看了队列的头元素，但没有删除它，并查看了队列的大小。
这个示例只展示了Java的Queue接口的基本功能。在实际应用中，可能会使用更复杂的操作，例如优先队列（PriorityQueue）或者阻塞队列（BlockingQueue）等。
（五）集合（Set）
在Java中，Set是一种集合，它不允许包含重复元素，并且最多包含一个null元素。以下是使用Java中Set的示例：
import java.util.HashSet;
import java.util.Set;
public class SetExample {
public static void main(String[] args) {
// 创建一个新的Set对象
Set<String> set = new HashSet<>();
// 添加元素到Set中
set.add("A");
set.add("B");
set.add("C");
set.add("D");
// 输出Set的大小
System.out.println("Size of set: " + set.size());
// 检查一个元素是否在Set中
System.out.println("Contains A? " + set.contains("A"));
// 遍历并打印Set中的所有元素
for (String element : set) {
System.out.println(element);
}
// 删除一个元素
set.remove("B");
// 打印删除后的Set
System.out.println("After removing B: " + set);
}
}
在这个例子中，创建了一个HashSet，这是Set接口的一种实现。然后向这个Set添加了一些字符串元素，并检查了一个元素是否存在于Set中。遍历并打印了Set中的所有元素，然后删除了一个元素并打印了删除后的Set。
（六）映射（Map）
在Java中，Map是一种数据结构，可以存储键值对，其中键是唯一的。Map的常用实现类包括HashMap、TreeMap和LinkedHashMap等。以下是使用Java中Map的示例：
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
// 创建一个新的Map对象
Map<String, Integer> map = new HashMap<>();
// 向Map中添加元素
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);
// 获取Map中的元素
int age = map.get("Bob");
System.out.println("Bob's age is " + age);
// 检查Map中是否包含某个键
boolean containsKey = map.containsKey("Charlie");
System.out.println("Map contains Charlie's key: " + containsKey);
// 遍历Map中的所有键值对
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String name = entry.getKey();
int age = entry.getValue();
System.out.println(name + " is " + age + " years old.");
}
// 删除Map中的元素
map.remove("Alice");
System.out.println("After removing Alice: " + map);
}
}
在这个示例中，使用了一个HashMap来存储人名和对应的年龄。向Map中添加了一些元素，并使用get方法获取了其中一个元素的值。还使用containsKey方法检查了Map中是否包含某个键，并使用entrySet方法遍历了Map中的所有键值对。最后，使用remove方法删除了Map中的一个元素。
（七）树（Tree）
在Java中，树是一种非线性的数据结构，它用于表示具有层次关系的数据。每个树都由一个根节点和零个或多个子树组成，每个子树也是一个树。以下是一个简单的Java示例，演示了如何定义一个基本的树结构：
// 定义一个树结构节点
class TreeNode {
int value;
TreeNode left;
TreeNode right;
// 构造方法
TreeNode(int value) {
this.value = value;
this.left = null;
this.right = null;
}
}
// 定义一个二叉树
public class BinaryTree {
TreeNode root;
// 构造方法
BinaryTree(int value) {
root = new TreeNode(value);
}
// 为了简单起见，这个例子中我们将只打印树的根节点值
public void printRootValue() {
System.out.println("Root Value: " + root.value);
}
public static void main(String[] args) {
// 创建一个新的二叉树
BinaryTree tree = new BinaryTree(1);
// 打印根节点的值
tree.printRootValue();
}
}
在这个例子中，创建了一个二叉树，也就是说每个节点最多有两个子节点（可能为零个，即该节点为叶子节点）。每个节点有一个值，以及指向其左右子节点的引用。还定义了一个方法来打印树的根节点的值。当然，实际使用中，可能需要更多的方法来操作树，比如插入新节点、删除节点、搜索值等等。
（八）图（Graph）
在Java中，图（Graph）是一种常见的数据结构，用于表示对象之间的关系。下面是一个简单的示例，演示了如何使用Java实现一个图数据结构：
首先，需要定义图的基本元素：顶点和边。
- 定义顶点类
Vertex：
public class Vertex {
private String label;
private int index;
public Vertex(String label, int index) {
this.label = label;
this.index = index;
}
public String getLabel() {
return label;
}
public int getIndex() {
return index;
}
}
- 定义边类
Edge：
public class Edge {
private Vertex from;
private Vertex to;
private int weight;
public Edge(Vertex from, Vertex to, int weight) {
this.from = from;
this.to = to;
this.weight = weight;
}
public Vertex getFrom() {
return from;
}
public Vertex getTo() {
return to;
}
public int getWeight() {
return weight;
}
}
接下来，定义一个图类 Graph，并在其中实现图的基本操作：添加顶点、添加边、打印图等。
- 定义图类
Graph：
import java.util.*;
public class Graph {
private List<Vertex> vertices;
private List<Edge> edges;
public Graph() {
vertices = new ArrayList<>();
edges = new ArrayList<>();
}
public void addVertex(Vertex vertex) {
vertices.add(vertex);
}
public void addEdge(Edge edge) {
edges.add(edge);
}
public void printGraph() {
System.out.println("Vertices:");
for (Vertex vertex : vertices) {
System.out.println("Label: " + vertex.getLabel() + ", Index: " + vertex.getIndex());
}
System.out.println("Edges:");
for (Edge edge : edges) {
System.out.println("From: " + edge.getFrom().getLabel() + ", To: " + edge.getTo().getLabel() + ", Weight: " + edge.getWeight());
}
}
}
现在，可以创建一个图并对其进行操作：
- 主类
Main：
public class Main {
public static void main(String[] args) {
Graph graph = new Graph();
Vertex v1 = new Vertex("A", 0);
Vertex v2 = new Vertex("B", 1);
Vertex v3 = new Vertex("C", 2);
graph.addVertex(v1);
graph.addVertex(v2);
graph.addVertex(v3);
graph.addEdge(new Edge(v1, v2, 1));
graph.addEdge(new Edge(v2, v3, 2));
graph.addEdge(new Edge(v3, v1, 3));
graph.printGraph();
}
}
在这个例子中，创建了一个简单的无向图，其中包含三个节点A、B和C，以及三条边连接它们。边的权重分别表示从A到B的距离为1，从B到C的距离为2，以及从C到A的距离为3。这些权重可以解释为任意两个节点之间的距离，例如，节点A和节点B之间的距离为1，节点B和节点C之间的距离为2，以此类推。
为了完整地表示这个图，可以使用邻接矩阵来表示它。邻接矩阵是一个二维数组，其中行和列都表示图中的节点，矩阵中的元素表示两个节点之间是否有边相连，以及边的权重。在这个例子中，邻接矩阵可以如下所示：
A B C
A 0 1 3
B 1 0 2
C 3 2 0
其中第一行第二列的元素为1，表示从A到B有一条权重为1的边；第二行第三列的元素为2，表示从B到C有一条权重为2的边；以此类推。
除了邻接矩阵之外，还可以使用邻接列表来表示图。邻接列表是一个数组，其中每个元素都表示一个节点及其相邻的节点和边。例如，对于上面的图，邻接列表可以如下所示：
A: B(1) C(3)
B: A(1) C(2)
C: A(3) B(2)
其中第一行的第一个元素A表示起点节点，后面的冒号后跟着它的相邻节点和相应的边的权重。例如，从A到B有一条权重为1的边，从A到C有一条权重为3的边。以此类推，对于其他节点也是如此。