Java语言的数据结构与算法

霍离湮

于 2025-03-16 08:26:36 发布

阅读量309

点赞数 6

分类专栏：包罗万象文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/2501_91201189/article/details/146290271

版权

包罗万象专栏收录该内容

23 篇文章

订阅专栏

Java语言的数据结构与算法

在软件开发中，数据结构与算法是两个不可或缺的核心概念。良好的数据结构可以有效地组织和存储数据，而高效的算法可以有效地处理这些数据。在Java语言中，数据结构与算法的结合使得开发者能够创建高效、优雅和可维护的应用程序。

一、数据结构的基本概念

数据结构是计算机中存储、组织和管理数据的方式。选择合适的数据结构能够提高程序的执行效率和维护性。常见的数据结构有数组、链表、栈、队列、树、图和哈希表等。

1.1 数组

数组是最基本的数据结构，它是一个固定大小的、有序的元素集合。数组的优势在于其对元素的随机访问能力，时间复杂度为O(1)。然而，数组的缺点是其大小固定，插入和删除元素的时间复杂度为O(n)。

java int[] arr = new int[5]; // 创建一个大小为5的整型数组 arr[0] = 1; // 数组赋值

1.2 链表

链表是由一系列节点构成的线性数据结构，每个节点包含数据部分和指向下一个节点的指针。链表的插入和删除操作非常高效，时间复杂度为O(1)，但随机访问的时间复杂度为O(n)。

```java class Node { int data; Node next;

Node(int data) {
    this.data = data;
    this.next = null;
}

} ```

1.3 栈

栈是一种后进先出（LIFO）的数据结构，支持push（入栈）和pop（出栈）操作。栈在函数调用、表达式求值和括号匹配等场景中非常有用。

java Stack<Integer> stack = new Stack<>(); stack.push(1); stack.push(2); int top = stack.pop(); // top 为 2

1.4 队列

队列是一种先进先出（FIFO）的数据结构，支持enqueue（入队）和dequeue（出队）操作。队列适用于任务调度、缓冲区等场景。

java Queue<Integer> queue = new LinkedList<>(); queue.offer(1); queue.offer(2); int first = queue.poll(); // first 为 1

1.5 树

树是一种分层的数据结构，常用来表示具有父子关系的数据。二叉树是每个节点最多有两个子节点的树，平衡二叉树可以保持高效的查找、插入和删除操作。

```java class TreeNode { int val; TreeNode left; TreeNode right;

TreeNode(int val) {
    this.val = val;
}

} ```

1.6 图

图由节点和连接这些节点的边组成，常用于表示网络、关系等复杂数据。图分为有向图和无向图，常用的图遍历算法有深度优先搜索（DFS）和广度优先搜索（BFS）。

```java class Graph { private Map > adjList = new HashMap<>();

public void addEdge(int source, int destination) {
    adjList.putIfAbsent(source, new ArrayList<>());
    adjList.get(source).add(destination);
}

} ```

1.7 哈希表

哈希表是一种通过哈希函数将键映射到值的数据结构，可以提供高效的查找、插入和删除操作。Java中的HashMap非常常用。

java Map<String, Integer> map = new HashMap<>(); map.put("One", 1); map.put("Two", 2); int value = map.get("One"); // value 为 1

二、常用算法

在计算机科学中，算法是处理数据、实现功能的步骤和过程。常见的算法包括排序、查找、递归、动态规划等。

2.1 排序算法

排序算法用于将数据按照特定顺序排列。常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

2.1.1 冒泡排序

冒泡排序是一种简单的排序算法，通过重复地遍历待排序数组，比较相邻元素并交换位置，使得较大的元素逐渐“冒泡”到数组的尾部。

java public void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) { // 交换 int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } }

2.1.2 快速排序

快速排序是一种分治法的高效排序算法，平均时间复杂度为O(n log n)。

```java public void quickSort(int[] arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } }

private int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = (low - 1); for (int j = low; j < high; j++) { if (arr[j] < pivot) { i++; // 交换 int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 交换 int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } ```

2.2 查找算法

查找算法用于在数据结构中查找元素。常见的查找算法有线性查找和二分查找。

2.2.1 线性查找

线性查找逐个对比数组中的每个元素，直到找到目标元素。

java public int linearSearch(int[] arr, int target) { for (int i = 0; i < arr.length; i++) { if (arr[i] == target) { return i; // 返回索引 } } return -1; // 未找到 }

2.2.2 二分查找

二分查找需要对已排序的数组进行搜索，通过每次将搜索范围减半，不断地缩小范围，直到找到目标元素。

```java public int binarySearch(int[] arr, int target) { int low = 0; int high = arr.length - 1;

while (low <= high) {
    int mid = low + (high - low) / 2;
    if (arr[mid] == target) {
        return mid;  // 返回索引
    }
    if (arr[mid] < target) {
        low = mid + 1;
    } else {
        high = mid - 1;
    }
}
return -1;  // 未找到

} ```

2.3 递归算法

递归是一种解决问题的方法，其中函数直接或间接地调用自身。常用于解决分治、查找和组合等问题。

java public int factorial(int n) { if (n == 0) { return 1; } return n * factorial(n - 1); }

2.4 动态规划

动态规划是一种解决复杂问题的方法，它将复杂问题分解成更简单的子问题，保存已解决的子问题以避免重复计算。

java public int fibonacci(int n) { if (n <= 1) { return n; } int[] dp = new int[n + 1]; dp[0] = 0; dp[1] = 1; for (int i = 2; i <= n; i++) { dp[i] = dp[i - 1] + dp[i - 2]; } return dp[n]; }