数据结构

技术思考者

已于 2023-08-27 15:50:24 修改

阅读量169

点赞数 1

分类专栏：算法文章标签：数据结构算法 java

于 2023-08-02 20:47:04 首次发布

本文链接：https://blog.csdn.net/m0_56925275/article/details/132071083

版权

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

数组

概念

数组（Array）是一种线性数据结构，它是一组相同类型的元素按顺序排列的集合。每个元素在数组中都有一个唯一的索引，通过索引可以快速访问和操作数组中的元素。

元素（Element）：数组中的元素是数据的项，可以是数字、字符、对象等。每个元素都占据数组中的一个位置。
索引（Index）：数组中每个元素都有一个与之对应的唯一索引值，用于标识元素在数组中的位置。索引通常从0开始，依次递增。

特点

相同类型的元素：数组中的元素必须是相同类型的，可以是数字、字符、对象等。这样可以确保数组在内存中以连续的方式存储，便于访问和处理。
大小固定：数组在创建时就需要指定大小，一旦创建后，大小就固定不变，无法动态调整。如果需要存储更多元素，就需要创建一个更大的数组并将原数组的元素复制过来。
连续内存空间：数组中的元素在内存中是连续存储的，每个元素占用固定的内存空间。可以通过通过索引值可以直接计算出元素在内存中的地址，实现快速访问。这使得访问和修改元素的时间复杂度为O(1)。
唯一索引：数组中的每个元素都有一个唯一的索引值。索引从0开始递增，可以通过索引访问和操作数组中的元素，索引值与元素在数组中的位置一一对应。
有序集合：数组中的元素按照顺序存储，保持了元素在数组中的顺序关系。这样可以方便地对数组进行遍历、搜索和排序等操作。
访问效率高：由于数组中的元素是连续存储的，通过索引值可以直接计算出元素的内存地址，因此可以快速访问数组中的任意元素。
插入和删除效率较低：由于数组的大小固定且连续存储，插入和删除元素时需要移动其他元素。特别是在数组的开头或中间插入和删除元素时，需要移动大量元素，导致效率较低。

数组的特性对于不同的编程语言和环境可能会有一些差异，比如在某些语言中可能支持动态数组，可以自动调整大小。但总体上，数组都具备上述的基本特点。

使用

下面是数组的基本使用方法：

创建数组：
要创建一个数组，需要指定数组类型和大小。例如，以下代码创建了一个包含5个整数的数组：
```
int[] numbers = new int[5];
```
访问数组元素：
可以使用索引来访问数组中的元素。索引从0开始，直到数组的大小减1。例如，以下代码分别将值10存储在索引0处，并将索引2处的值赋给变量x：
```
numbers[0] = 10;
int x = numbers[2];
```

循环遍历数组：
可以使用循环遍历数组中的所有元素。例如，以下代码使用for循环打印数组中的所有元素：

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}
System.out.println(Arrays.toString(numbers));

使用初始化列表初始化数组：
除了使用new关键字创建数组之外，还可以使用初始化列表创建并初始化数组。例如，以下代码创建了一个包含初始值的数组：
```
int[] arr = new int[3]; arr[x] = xx; // 动态初始化
int[] numbers = {1, 2, 3, 4, 5}; // 静态初始化，比较方便。
```
多维数组：
除了一维数组，Java还支持多维数组。例如，以下代码创建了一个包含3行3列的二维数组：
```
int[][] matrix = new int[3][3];
```

数组排序

public static void main(String[] args) {
    int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
    // 排序前:
    System.out.println(Arrays.toString(ns));
    for (int i = 0；i < ns.length - 1；i++) {
        for (int j = 0；j < ns.length - i - 1；j++) {
            if (ns[j] > ns[j+1]) {
                // 交换ns[j]和ns[j+1]:
                int tmp = ns[j];
                ns[j] = ns[j+1];
                ns[j+1] = tmp;
            }
        }
    }
    // 排序后:
    System.out.println(Arrays.toString(ns));
}

注意：在我们使用数组时，要确保索引的范围是合法的，否则可能会导致数组越界的错误。要注意对数组大小和索引的管理，以避免访问和操作不正确的数组元素。

public static void main(String[] args) {
    int[] arr = new int[2];
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;// 编译通过，运行时产生：ArrayIndexOutOfBoundsException(数组索引越界异常)*
    arr[3] = 40;
}

public static void main(String[] args) {
    int[] arr = new int[3];//int[] arr = 111;
    arr = null;
    // arr[0] = 100;// 编译通过，运行时出现：空指针异常——NullPointerException
    for (int i = 0; i < arr.length; i++) {// 编译通过，运行时出现：arr.length同样也会引发“空指针异常”
        System.out.println(arr[i]);
    }
}

应用场景

应用于需要频繁快速访问元素，并且元素数量固定不变的情况。如：

集合和序列的存储：数组可用于存储一组数据，如整数、字符串或其他数据类型。例如，存储学生成绩、员工信息或日程安排等。
数据的遍历和访问：由于数组中的元素按照顺序存储，因此可以使用循环结构（如for循环）遍历数组中的所有元素。这样可以方便地对数组中的数据进行访问和处理。
排序和搜索算法：数组可用于实现各种排序算法，如冒泡排序、快速排序、归并排序等。此外，可以使用数组来存储数据，并使用搜索算法如二分查找来查找特定元素。
堆栈和队列：可以使用数组来实现堆栈（先进后出）和队列（先进先出）这两种数据结构。堆栈和队列的操作通常是在数组的一端进行插入和删除。
图像和音频处理：数组可以用于存储图像的像素值和音频的采样数据。这样可以方便地对图像和音频进行处理和操作。
多维数组：数组可以有多个维度，用于存储矩阵、图表等数据结构。多维数组在科学计算、图像处理、游戏开发等领域得到广泛应用。

链表

概念

链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成，每个节点包含一个数据元素和一个指向下一个节点的引用（指针）。相比于数组，链表的特点是节点之间的连接不是通过连续的内存空间来实现，而是通过指针进行连接。

节点（Node）：链表由一个个节点组成，每个节点包含一个数据元素（可以是任意类型）和一个指向下一个节点的指针。
头节点（Head）：链表的头部节点，作为链表的起始点进行访问。
尾节点（Tail）：链表的尾部节点，指向链表中最后一个节点。尾节点的指针通常为空（null）。
节点之间的连接：链表中的每个节点都包含一个指针，指向下一个节点。通过这种指针连接，形成了链表的结构。

链表根据节点间的链接方式可以分为单向链表和双向链表两种常见类型：

单向链表（Singly Linked List）：每个节点只有一个指针，指向下一个节点。最后一个节点的指针指向空。
双向链表（Doubly Linked List）：每个节点有两个指针，分别指向上一个节点和下一个节点。首尾节点的指针可能为 null

相对于数组，链表的主要优势是插入和删除操作的效率较高。由于链表的节点可以存储在任意位置，插入或删除一个节点只需要修改相应节点的指针，而不需要移动其他节点。然而，链表的缺点是访问效率较低，无法像数组那样通过索引直接访问元素，需要从头节点开始遍历链表。

特点

动态性：链表的长度可以根据需要动态增长或缩短，相比较数组而言更加灵活。
插入和删除操作高效：由于链表是通过指针相互连接的节点来组成的，插入和删除节点的操作相对较快。在链表中插入或删除一个节点只需要调整相邻节点的指针，不需要像数组那样搬移大量元素。
内存空间利用率相对较低：链表节点由数据元素和指针组成，因此占用的内存空间相对较大。
随机访问较慢：链表的节点没有顺序编号，需要从头节点依次遍历到目标节点才能进行访问。这导致链表在需要随机访问的情况下不如数组高效。
支持动态顺序调整：链表的节点可以通过修改指针的方式实现顺序的调整，比如反转链表、交换节点等操作。
灵活性：链表可以根据具体的需求设计不同类型的链表，如单向链表、双向链表、循环链表等。

使用

Java中内置的LinkedList类是一种实现链表数据结构的类，它提供了许多方便的方法来操作链表。

下面是使用LinkedList类的几个示例：

创建和添加节点：
要创建一个空的LinkedList对象，可以使用无参数的构造函数。然后，可以使用add()方法向链表中添加节点。例如：
```
LinkedList<Integer> linkedList = new LinkedList<>();
linkedList.add(1); // 添加一个节点
linkedList.add(2); // 添加另一个节点
linkedList.add(3); // 添加第三个节点
```
创建了一个包含3个整数节点的链表。
插入节点：
使用LinkedList类，可以使用add(index, element)方法在指定位置插入节点。例如，以下代码在链表的第二个位置插入一个节点：
```
linkedList.add(1, 4); // 在索引为1的位置插入值为4的节点
```
将值为4的节点插入到索引为1的位置。
删除节点：
使用LinkedList类，可以使用remove(index)方法删除指定位置的节点。例如，以下代码删除链表的第三个节点：
```
linkedList.remove(2); // 删除索引为2的节点
```
将索引为2的节点从链表中移除。
遍历链表：
使用LinkedList类，可以使用增强的for循环或迭代器来遍历链表中的每个节点。例如，以下代码使用增强的for循环打印链表中的所有节点：
```
for (int num : linkedList) {
    System.out.println(num);
}
```
逐个打印链表中的每个节点的值。

LinkedList类还提供了其他许多有用的方法，如获取链表的长度、获取头部和尾部节点等。希望这能提供给你一个链表的简单使用理解。

应用场景

应用于频繁插入和删除元素，但对元素的随机访问不是主要需求的场景。如：

实现栈和队列：链表可以用来实现栈和队列，因为它们的插入和删除操作都可以在常数时间内完成。
实现图和树的数据结构：链表可以用来表示图和树的节点。每个节点可以包含指向其他节点的指针，从而构建出复杂的数据结构。
实现哈希表：链表可以用作哈希表的桶，每个桶中存储具有相同哈希值的元素。当发生哈希冲突时，使用链表将其链接在一起，以便进行快速查找和插入操作。
实现缓存：链表可以用作缓存的数据结构，当需要添加、删除和访问缓存数据时，链表提供了高效的操作。
任务调度器：链表可以用于实现任务调度器，每个节点代表一个任务，按照一定的优先级进行管理和执行。
单向链表和双向链表使用场景：单向链表适用于只需要从头到尾依次遍历的场景，而双向链表适用于需要在链表中进行双向遍历的场景。

总的来说，链表广泛应用于需要频繁进行插入、删除和动态增长的场景，以及对内存空间的利用要求较高的场景。

栈

概念

栈（Stack）是一种经典的线性数据结构，它遵循一种特定的操作规则，即"先进后出"（Last In, First Out，LIFO）。栈可以被视为一种容器，其中元素只能从容器的一端进行插入和删除操作，该端称为栈顶。

栈的概念可以用类比于现实生活中的一叠盘子。当我们将盘子叠放在一起时，只能从最顶端放入或取出盘子。最后一个放入的盘子是第一个被取出来的。

栈主要支持以下几种基本操作：

入栈（Push）：将元素添加到栈顶。新的元素成为栈顶，原来栈顶的元素依次下移。
出栈（Pop）：从栈顶移除元素。被移除的是最后一个入栈的元素，栈顶下移。

栈还可以支持其他辅助操作：

栈顶元素（Top）：返回栈顶的元素，但不对栈进行修改。
栈的大小（Size）：返回栈中元素的个数。

栈的实现可以使用数组或链表。用数组实现的栈通常需要预先确定栈的最大容量，而用链表实现的栈可以动态扩展。

特点

栈是一种具有特定操作规则的线性数据结构。

先进后出（Last In, First Out，LIFO）：栈中最后一个入栈的元素将成为第一个出栈的元素。最先入栈的元素将保持在栈底，只有当栈顶元素出栈后，才能访问到栈底的元素。
只能在栈顶进行插入和删除操作：栈的操作限制了元素的插入和删除只能在栈顶进行，即元素只能从栈顶进入或离开。插入操作称为入栈（Push），删除操作称为出栈（Pop）。
后进入的元素先出栈：最新入栈的元素将成为下一个出栈的元素，保持了元素的顺序逆序。
栈的大小可以动态变化：栈可以根据需要动态扩展或缩小。
栈顶是单向访问的唯一点：在栈中只能通过栈顶访问元素，无法直接访问其他位置的元素，即无法随机访问。
栈的插入和删除操作具有常数时间复杂度：入栈和出栈操作的时间复杂度都是O(1)，即插入和删除元素的效率非常高。

使用

下面是栈的基本使用方法：

创建栈：
首先，需要导入 java.util.Stack 类，然后可以使用无参数的构造函数创建一个空栈。例如：
```
Stack<Integer> stack = new Stack<>();
```
这会创建一个整数类型的空栈。
入栈操作：
使用 push() 方法将元素压入栈中。例如：
```
stack.push(1);   // 将1压入栈顶
stack.push(2);   // 将2压入栈顶
stack.push(3);   // 将3压入栈顶
```
这会将元素依次压入栈中，栈顶元素为最后一个压入的元素。
出栈操作：
使用 pop() 方法从栈顶移除并返回栈顶元素。例如：
```
int top = stack.pop();   // 弹出栈顶元素
```
这会将栈顶元素弹出，并将其赋值给变量 top。
获取栈顶元素：
使用 peek() 方法可以获取但不移除栈顶元素。例如：
```
int top = stack.peek();   // 获取栈顶元素，但不移除
```
这会获取栈顶元素，并将其赋值给变量 top。
判断栈是否为空：
使用 isEmpty() 方法可以检查栈是否为空。例如：
```
boolean isEmpty = stack.isEmpty();   // 判断栈是否为空
```
这会返回一个布尔值，指示栈是否为空。

Java的Stack类实际上是Vector类的子类，因此它继承了Vector类的一些方法。但在栈的使用场景中，通常只使用了Stack类的特定方法来实现栈的操作。

应用场景

应用于需要按照特定顺序处理数据、实现数据的临时保存和撤销等场景中，如：

函数调用：栈常用于存储函数调用的上下文信息，包括函数的参数、返回地址和局部变量等。每次调用函数时，将当前上下文信息压入栈中，函数返回时再从栈中弹出上一个上下文信息，实现函数调用的嵌套和返回操作。
表达式求值：栈常用于解析和求值数学表达式，如中缀表达式转后缀表达式。通过栈来保存运算符及其优先级，按照优先级顺序进行计算，最终求得表达式的结果。
括号匹配：栈可用于检测括号是否匹配。遍历字符串时，遇到左括号时将其压入栈中，遇到右括号时从栈中弹出一个左括号，如果弹出不匹配，则表示括号不匹配。
浏览器的"后退"功能：浏览器使用一个栈来维护访问历史记录。每当访问一个新页面时，将该页面的信息压入栈中；当点击"后退"功能时，从栈中弹出最近的页面信息，实现返回到上一个页面。
编辑器的"撤销"功能：编辑器使用栈来管理操作的历史记录。每当用户执行一个操作时，将操作的信息压入栈中；当用户点击"撤销"功能时，从栈中弹出最近的操作信息，实现撤销操作。
迷宫求解：在迷宫求解算法中，使用栈来保存路径信息。从起点开始，按照一定规则选择下一个可行的路径，并将路径信息压入栈中，当到达终点或无可行路径时，从栈中弹出上一个路径信息，退回到上一个位置，继续搜索。

队列

概念

队列（Queue）是一种具有特定操作规则的线性数据结构，它遵循一种特定的操作规则，即"先进先出"（First In, First Out，FIFO）。队列可以看作是一种容器，元素按照添加的先后顺序排列，但只能从队列的一端（称为队尾）添加元素，从另一端（称为队头）移除元素。

队列的操作主要包括两个基本操作：

入队（Enqueue）：将元素添加到队尾。新的元素成为队列的最后一个元素。
出队（Dequeue）：从队头移除元素。被移除的是最先入队的元素，队列头部的元素被移除后，其后的元素依次前移。

队列还可以支持其他辅助操作，例如：

队头元素（Front）：返回队头的元素，但不对队列进行修改。
队列大小（Size）：返回队列中元素的个数。

队列类似于现实生活中的排队，第一个到达的人或元素首先离开队列，后来到达的人或元素依次等待。

特点

先进先出（First In, First Out，FIFO）：队列中最先加入的元素将首先被移除，保持了元素的顺序性。
只能在队尾插入，只能从队头删除：队列的元素只能从队尾添加，而只能从队头删除。新的元素被添加到队列的末尾，也就是队尾；而被移除的元素始终是队列的第一个元素，也就是队头。
后加入的元素后出队列：后入队列的元素将作为下一个出队列的元素。即队列中的元素按照加入的顺序进行处理。
队列大小可以动态变化：队列可以根据需要动态增长或缩小，没有固定的大小限制。
入队和出队操作的时间复杂度为 O(1)：向队尾插入元素和从队头删除元素的操作都只需常数时间，无论队列中的元素个数是多少。

使用

下面是队列的基本使用方法：

创建队列：
首先，需要导入 java.util.Queue 接口，然后可以使用该接口的实现类之一来创建队列。以下是使用LinkedList创建队列的示例：
```
Queue<Integer> queue = new LinkedList<>();
```
这会创建一个整数类型的空队列。

入队操作：
使用 offer() 方法将元素添加到队列的尾部。例如：

queue.offer(1);   // 将1添加到队列尾部
queue.offer(2);   // 将2添加到队列尾部
queue.offer(3);   // 将3添加到队列尾部

这会将元素依次添加到队列的尾部。

出队操作：
使用 poll() 方法从队列的头部移除并返回一个元素。例如：
```
int front = queue.poll();   // 从队列头部移除一个元素
```
这会从队列的头部移除一个元素，并将其赋值给变量 front。
获取队列头部元素：
使用 peek() 方法获取但不移除队列的头部元素。例如：
```
int front = queue.peek();   // 获取队列头部元素，但不移除
```
这会获取队列的头部元素，并将其赋值给变量 front。
判断队列是否为空：
使用 isEmpty() 方法可以检查队列是否为空。例如：
```
boolean isEmpty = queue.isEmpty();   // 判断队列是否为空
```
这会返回一个布尔值，指示队列是否为空。

Queue接口还定义了其他一些方法，如size()用于获取队列大小，contains()用于检查队列是否包含某个元素等。

应用场景

应用于要实现按照顺序管理和处理任务、消息、数据包、作业等各种元素，使得处理过程更加有序和可控，如：

任务调度：队列常用于实现任务调度器。例如，在操作系统中，可以使用队列来管理待执行的进程或线程，按照先后顺序进行调度和执行。任务依次加入队列，然后从队头依次出队进行执行。
网络通信：队列常用于实现消息队列，在不同的组件或系统之间进行异步通信和消息传递。消息被放入队列的末尾，然后按照先后顺序依次从队头被获取并处理。
缓冲区管理：队列在网络数据包的接收和发送过程中起到了重要的作用。接收到的数据包被放入队列的末尾，然后按照先后顺序依次从队头获取并进行处理。类似地，发送的数据包也可以先放入队列中，再按照顺序逐个进行发送。
打印队列：在打印机等资源有限的场景中，队列可用于排队并管理打印任务。每个打印任务依次加入队列尾部，然后从队头依次出队进行打印。
CPU调度：在多道批处理系统中，队列常用于管理待执行的进程。当一个进程完成后，下一个将依次从队头取出进行调度和执行。
广度优先搜索（BFS）：在图的广度优先搜索算法中，队列用于记录待探索的节点。首先将起始节点加入队列，然后依次从队头取出节点进行遍历，并将其邻接节点加入队列，以此按照广度优先的顺序进行遍历。
急救和医疗系统：队列常用于管理急救流程中的患者。患者按照优先级加入队列，然后按照先后顺序从队头取出进行处理。
消息处理系统：例如电子邮件服务器，使用队列按照接收的顺序将邮件排队并逐个处理。邮件依次加入队列尾部，然后按照顺序从队头依次处理。
资源池管理：例如线程池、连接池等，队列可用于管理和分配有限资源的请求。请求依次加入队列，然后从队头依次处理，并分配可用的资源。
计算机作业调度：队列常用于管理计算机作业的调度顺序。作业按照优先级和提交时间加入队列，然后依次从队头取出进行处理。

树

概念

树（Tree）是一种分层的非线性数据结构，由一组节点（Node）以及节点之间的链接（Edge）组成。树是一种层次化的结构，其中根节点表示顶级节点，分支表示节点之间的关系，叶子表示没有子节点的节点。

节点（Node）：树由节点组成，每个节点包含数据（Value）和指向其他节点的引用（Children）。节点可以包含零个或多个子节点。
根节点（Root）：树的根节点是树的起点，它没有父节点，是整个树的顶级节点。
子节点（Children）和父节点（Parent）：除了根节点外，每个节点都有且仅有一个父节点，节点之间通过边（连接父节点和子节点的链接）形成父子关系。父节点可以有多个子节点。
叶节点（Leaf）：树中没有子节点的节点被称为叶节点，也叫做终端节点。它们位于树的最底层。
路径（Path）：路径是指从树的任一节点到达另一个节点所经过的边的序列。路径的长度是指路径上的边的数量。
子树（Subtree）：树中的每个节点都可以作为根节点，形成一个子树。子树是由根节点及其所有后代节点组成的完整树。

特点

分层结构：树是一种分层结构，其中的节点通过连接的边按层次分布。顶层节点为根节点，层次逐渐向下增加。
拥有唯一的根节点：树只能有一个根节点，它是整个树的起点。根节点没有父节点，是树的顶级节点。
有层次的节点关系：除了根节点外，每个节点都有且仅有一个父节点。节点通过边连接到其父节点，并可以拥有零个或多个子节点。节点之间的父子关系构成树的层次结构。
叶节点和内部节点：没有子节点的节点称为叶节点或终端节点，它们位于树的最底层。具有子节点的节点称为内部节点。
链接的边：树的节点之间由边连接，边表示节点之间的关联关系。边定义了节点的父子关系，并提供了在树中导航的途径。
递归性质：树的结构具有递归性质，每个子节点本身也可以看作一个树。每个节点及其子节点构成的子树是原树的一部分，也是一个完整的树。
深度和高度：树的深度是指从根节点到叶节点的最长路径的长度。树的高度是指树中任意节点到叶节点的最长路径的长度。
具有多个子树的节点：树中的节点可以有零个或多个子节点。如果一个节点具有多个子节点，则它们之间没有顺序关系。

使用

Java中没有直接的Tree类，但我们可以使用节点类和一些操作来创建和使用树。

下面是树的基本使用方法：

创建节点类：
首先，需要定义一个节点类，用于表示树中的每个节点。节点类通常包含一个数据字段和指向子节点的引用字段。例如：
```
class TreeNode {
    int data;
    List<TreeNode> children;

    public TreeNode(int data) {
        this.data = data;
        this.children = new ArrayList<>();
    }
}
```
在节点类中，可以定义其他方法来操作节点，如添加子节点、获取子节点等。

构建树：
使用节点类，可以创建树。树由节点之间的链接关系组成。以下是一个示例，创建一棵树并添加节点：

TreeNode root = new TreeNode(1); // 创建根节点
TreeNode child1 = new TreeNode(2); // 创建子节点1
TreeNode child2 = new TreeNode(3); // 创建子节点2

root.children.add(child1); // 将子节点1添加到根节点的子节点列表中
root.children.add(child2); // 将子节点2添加到根节点的子节点列表中

这个示例创建了一个根节点为1的树，根节点有两个子节点2和3。

遍历树：
遍历树是指访问树中的每个节点，并按照特定的顺序处理节点。常用的树遍历方式有先序遍历、中序遍历和后序遍历。以下是使用递归进行先序遍历的示例：

public void preorderTraversal(TreeNode root) {
    if (root == null) {
        return;
    }

    System.out.println(root.data); // 处理根节点
    for (TreeNode child : root.children) {
        preorderTraversal(child); // 递归处理子节点
    }
}

上述代码使用先序遍历方式遍历树中的每个节点，并打印出节点的值。

查找节点：
如果树是二叉树，可以通过递归方式查找指定值的节点。示例如下：

public TreeNode findNode(TreeNode root, int target) {
    if (root == null) {
        return null;
    }

    if (root.data == target) {
        return root;
    }

    TreeNode foundNode = findNode(root.left, target); // 在左子树中查找
    if (foundNode == null) {
        foundNode = findNode(root.right, target); // 在右子树中查找
    }

    return foundNode;
}

上述代码使用递归方式在二叉树中查找值为target的节点，并返回找到的节点。

删除节点：
删除节点的操作依赖于树的类型和应用场景。以下是一个删除指定值节点的示例（仅适用于二叉树）：

public TreeNode deleteNode(TreeNode root, int target) {
    if (root == null) {
        return null;
    }

    if (root.data == target) {
        if (root.left == null) {
            return root.right; // 如果只有右子节点，将右子节点作为当前节点
        } else if (root.right == null) {
            return root.left; // 如果只有左子节点，将左子节点作为当前节点
        } else {
            TreeNode minNode = findMinNode(root.right); // 找到右子树中的最小节点
            root.data = minNode.data; // 将最小节点的值赋给当前节点
            root.right = deleteNode(root.right, minNode.data); // 在右子树中删除最小节点
        }
    } else if (target < root.data) {
        root.left = deleteNode(root.left, target); // 在左子树中删除节点
    } else {
        root.right = deleteNode(root.right, target); // 在右子树中删除节点
    }

    return root;
}

private TreeNode findMinNode(TreeNode node) {
    while (node.left != null) {
        node = node.left;
    }
    return node;
}

上述代码使用递归方式删除二叉树中值为target的节点。删除节点时，需要考虑节点的左右子树，并找到右子树中的最小节点作为替代。

其他操作：
树的其他常见操作包括计算树的深度、判断树是否平衡、获取树的节点数量等。这些操作的具体实现方式取决于树的类型和数据结构的选择。

应用场景

文件系统：文件系统中的文件和文件夹通常可以使用树结构进行组织和管理。每个文件夹对应一个节点，节点之间的关系由文件夹的嵌套关系确定。
数据库索引：数据库中的索引通常使用树结构，如B树（B-tree）和B+树（B+ tree）等。树的结构可以有效地提高搜索和查找的效率。
组织结构：组织结构中的部门和员工通常可以用树结构进行组织，每个节点表示一个部门或员工，而边则表示上下级关系。
编译器：编译器在语法分析阶段使用语法树（Syntax Tree）来表示程序的语法结构，以便后续的语义分析和代码生成。
网路路由：在网络中，路由算法可以使用树结构，如最短路径树（Shortest Path Tree）和路由表（Routing Table），来确定数据包的传输路径。
平衡二叉搜索树：平衡二叉搜索树（Balanced Binary Search Tree）是一种特殊的树结构，用于高效地存储和查找有序数据。
表达式解析和计算：树可以用于解析和计算数学表达式、逻辑表达式和布尔表达式。
决策树：决策树是一种用于分类和预测的树结构，常被用于机器学习和数据挖掘领域。

总而言之，树结构在各种领域和问题中具有广泛的应用。它提供了一种灵活且高效的方式来组织和处理数据，并表示复杂的关系和层次性结构。树及其变种结构为解决实际问题和优化算法提供了有力的工具。

图

概念

图（Graph）是由节点（Vertex）和边（Edge）构成的非线性数据结构，用于表示不同对象之间的关系。图由一组节点和连接节点的边组成，节点用于表示实体，而边表示节点之间的连接关系。

节点（Vertex）：节点代表图中的实体，也被称为顶点。每个节点可以具有一个或多个属性，如标签或值。
边（Edge）：边用于表示节点之间的连接关系。边可以是有向的，指向一个方向，或无向的，表示双向连接；边可以有权重（Weight），表示节点之间的关系强度。
顶点对（Vertex Pair）：边连接了两个节点，这两个节点被称为顶点对。在有向图中，连接的方向从一个顶点（起始顶点）指向另一个顶点（目标顶点）。
路径（Path）：路径是由一系列边连接的节点序列。路径的长度是指路径上经过的边的数量。
有向图（Directed Graph）：有向图中的边具有方向，从一个节点指向另一个节点。有向图中的边可用于表示单向关系。
无向图（Undirected Graph）：无向图中的边没有方向，表示节点之间的关系是双向的。
加权图（Weighted Graph）：加权图中的边具有权重，用于表示节点之间的关系强度或成本。
网络图（Network Graph）：网络图是一种特殊的图，用于表示计算机网络、社交网络等复杂的关系网。
连通图（Connected Graph）：连通图中，每对节点之间至少存在一条路径，节点之间可以相互到达。
强连通图（Strongly Connected Graph）：在有向图中，如果任意两个节点之间都存在互相可达的路径，则称该有向图是强连通图。

特点

表示关系：图用于表示和解释节点之间的各种关系，如社交网络中的朋友关系、城市间的道路连接、计算机网络中的节点通信等。
复杂性：图可以表示复杂的数据结构和关系，能够处理多对多的关联关系。
灵活性：图的结构非常灵活，可以动态调整节点和边的关系，适用于各种问题和情景。
高级分析和算法：许多高级算法和分析技术可应用于图，如最短路径算法、网络流算法和图聚类算法等。

使用

有两种主要的图表示方式：邻接矩阵（Adjacency Matrix）和邻接表（Adjacency List），Java中可以使用对象和集合类来表示和操作图。

下面是使用邻接表表示图的基本使用方法：

创建图：
首先，需要定义一个图类，其中包含节点和节点之间的连接关系。一个简单的图类示例如下：

import java.util.ArrayList;
import java.util.List;

class Graph {
    private int numVertices; // 图的顶点数量
    private List<List<Integer>> adjList; // 邻接表

    public Graph(int numVertices) {
        this.numVertices = numVertices;
        this.adjList = new ArrayList<>();

        for (int i = 0; i < numVertices; i++) {
            adjList.add(new ArrayList<>());
        }
    }

    // 添加边，构建图的连接关系
    public void addEdge(int src, int dest) {
        adjList.get(src).add(dest);
        adjList.get(dest).add(src); // 无向图需要添加双向边
    }

    // 获取图中顶点的数量
    public int getNumVertices() {
        return numVertices;
    }

    // 获取指定顶点的相邻顶点列表
    public List<Integer> getAdjacentVertices(int vertex) {
        return adjList.get(vertex);
    }
}

在上述示例中，我们使用了一个二维列表 adjList（邻接表）来存储每个顶点的相邻顶点。

添加边：
使用 addEdge() 方法向图中添加边，构建图的连接关系。例如：

Graph graph = new Graph(5); // 创建5个顶点的图
graph.addEdge(0, 1); // 添加边1-0
graph.addEdge(1, 2); // 添加边1-2
graph.addEdge(2, 3); // 添加边2-3
graph.addEdge(3, 4); // 添加边3-4
graph.addEdge(4, 0); // 添加边4-0

这会构建一个具有5个顶点和5条边的图。

获取顶点的相邻顶点列表：
使用 getAdjacentVertices() 方法可以获取指定顶点的相邻顶点列表。例如：
```
List<Integer> adjacentVertices = graph.getAdjacentVertices(2); // 获取顶点2的相邻顶点列表
```
这会返回顶点2的相邻顶点列表。

其他操作：

深度优先搜索（DFS）：
深度优先搜索是一种用于遍历图的算法，它以深度优先的方式探索图的节点。以下是一个使用递归实现的深度优先搜索的示例：

public void DFS(Graph graph, int startVertex, boolean[] visited) {
    visited[startVertex] = true;
    System.out.println("Visited vertex: " + startVertex);

    List<Integer> adjacentVertices = graph.getAdjacentVertices(startVertex);
    for (int vertex : adjacentVertices) {
        if (!visited[vertex]) {
            DFS(graph, vertex, visited);
        }
    }
}

在上述示例中，通过递归方式以深度优先的顺序遍历图中的节点，并将访问过的节点标记为已访问。

广度优先搜索（BFS）：
广度优先搜索是一种用于遍历图的算法，它以广度优先的方式探索图的节点。以下是一个使用队列实现的广度优先搜索的示例：

import java.util.LinkedList;
import java.util.Queue;

public void BFS(Graph graph, int startVertex, boolean[] visited) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(startVertex);
    visited[startVertex] = true;

    while (!queue.isEmpty()) {
        int vertex = queue.poll();
        System.out.println("Visited vertex: " + vertex);

        List<Integer> adjacentVertices = graph.getAdjacentVertices(vertex);
        for (int v : adjacentVertices) {
            if (!visited[v]) {
                visited[v] = true;
                queue.offer(v);
            }
        }
    }
}

在上述示例中，通过使用队列以广度优先的顺序遍历图中的节点，并将访问过的节点标记为已访问。

寻找最短路径：
寻找最短路径是指查找从一个图中的一个节点到另一个节点的最短路径。常用的算法包括Dijkstra算法和BFS算法。以下是使用Dijkstra算法寻找最短路径的示例：

import java.util.*;

public void findShortestPath(Graph graph, int source, int destination) {
    int numVertices = graph.getNumVertices();
    int[] distances = new int[numVertices];
    Arrays.fill(distances, Integer.MAX_VALUE);
    distances[source] = 0;

    PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingInt(node -> node.distance));
    pq.offer(new Node(source, 0));

    while (!pq.isEmpty()) {
        Node node = pq.poll();
        int vertex = node.vertex;

        if (vertex == destination) {
            break; // 已找到最短路径
        }

        if (distances[vertex] < node.distance) {
            continue; // 已经处理过该节点
        }

        List<Integer> adjacentVertices = graph.getAdjacentVertices(vertex);
        for (int v : adjacentVertices) {
            int weight = 1; // 这里假设边的权重为1
            int distance = distances[vertex] + weight;
            if (distance < distances[v]) {
                distances[v] = distance;
                pq.offer(new Node(v, distance));
            }
        }
    }

    System.out.println("Shortest distance from " + source + " to " + destination + ": " + distances[destination]);
}

// 内部类，用于存储节点和距离
class Node {
    int vertex;
    int distance;

    public Node(int vertex, int distance) {
        this.vertex = vertex;
        this.distance = distance;
    }
}

在上述示例中，使用Dijkstra算法以权重为1的情况下寻找最短路径。

应用场景

应用于表示节点和边关系的非线性数据结构，适用于处理复杂的关系和问题，如：

社交网络分析：图可用于社交网络中的朋友关系、影响网络分析、社区发现等。
道路和交通网络：图可用于表示城市道路的连接关系、交通流量的分析和优化等。
网络和通信：图可用于表示计算机网络中的节点和连接、通信路由和流量管理等。
推荐系统：图可用于构建用户之间的关系图，实现个性化推荐和群组发现。
数据库和知识图谱：图数据库和知识图谱可用于存储和查询复杂的关系数据和知识模型。
生物信息学：图可用于基因组组装、蛋白质相互作用网络等生物数据分析。
Web网页链接分析：图可用于搜索引擎的页面排名、链接建设和网页聚类等。
运筹学和优化问题：图可用于解决路径规划、最短路径、网络流量分配等问题。

哈希表

概念

哈希表（HashMap）是一种常见的数据结构，它使用哈希函数（Hash Function）来将键（Key）映射到存储桶（Bucket）的索引位置。通过使用哈希函数，可以快速地插入、删除和查询键值对。哈希表是一种以键-值（Key-Value）对的形式存储数据的集合。

键和值：哈希表中的数据是以键-值对的形式存储的。键是唯一的，而值可以是重复的。
哈希函数：哈希函数将给定的键映射到唯一的哈希码（Hash Code）或索引位置。哈希函数的设计应该使得哈希码均匀分布，减少冲突的可能性。
存储桶：哈希表中的数据会根据哈希码分配到不同的存储桶中。每个存储桶可以存储多个键值对。

特点

插入和删除元素的效率高，同时可以快速查找元素，但是不保持元素的插入顺序。

快速的插入和查找：由于哈希函数的高效映射，哈希表可以在常数时间内插入和查找元素。这使得哈希表非常适用于需要快速查询和存储大量数据的场景。
灵活的存储空间：哈希表可以根据需要动态调整存储桶的数量和大小，以优化性能。
冲突处理：哈希表使用哈希函数将键映射到索引位置，但由于哈希函数的输出空间有限，不同的键可能会产生相同的哈希码，可能就会出现冲突。冲突处理是设计和实现哈希表时需要考虑的一项重要问题。常见的冲突解决方法有链表法和开放地址法。
空间效率：哈希表通常会使用额外的存储空间来保持存储桶、链表等数据结构。尽管哈希表的插入和查询非常高效，但在存储空间方面较传统的数组或链表可能更耗费一些。

使用

以下是哈希表的基本使用方法：

创建哈希表：
首先，需要导入 java.util.HashMap 类，然后可以使用无参数的构造函数创建一个空的哈希表。例如：
```
import java.util.HashMap;

HashMap<String, Integer> hashMap = new HashMap<>();
```
这会创建一个存储键为字符串类型、值为整数类型的空哈希表。
添加键值对：
使用 put() 方法向哈希表中添加键值对。例如：
```
hashMap.put("apple", 1);
hashMap.put("banana", 2);
hashMap.put("cherry", 3);
```
这会向哈希表中添加三个键值对。
获取值：
使用 get() 方法可以根据键获取对应的值。例如：
```
int value = hashMap.get("banana");
System.out.println(value); // 输出: 2
```
这会获取键为"banana"的值，并将其打印出来。
删除键值对：
使用 remove() 方法可以根据键删除对应的键值对。例如：
```
hashMap.remove("cherry");
```
这会移除键为"cherry"的键值对。
检查键是否存在：
使用 containsKey() 方法可以检查指定的键是否存在于哈希表中。例如：
```
boolean contains = hashMap.containsKey("apple");
System.out.println(contains); // 输出: true
```
这会检查键"apple"是否存在，如果存在，则返回true。