在 Java 中，算法是解决特定问题的一系列明确指令。以下是 Java 开发中常见的算法分类及示例：
- 排序算法
排序是将数据按特定顺序排列的过程。Java 提供了多种排序实现：
1.1 冒泡排序（Bubble Sort）
原理：重复比较相邻元素，若顺序错误则交换，直到整个数组有序。
时间复杂度：O(n²)
示例代码：
java
public class BubbleSort {
public static void sort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换元素
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}1.2 快速排序（Quick Sort） 原理：分治法，选择基准值，将数组分为两部分，递归排序。 时间复杂度：平均 O (n log n)，最坏 O (n²) Java 实现：Arrays.sort()（基本类型使用双轴快排）
1.3 归并排序（Merge Sort）
原理：分治法，将数组分成子数组，排序后合并。
时间复杂度：O(n log n)
Java 实现：Collections.sort()（基于归并排序）
- 搜索算法
搜索是在数据集合中查找特定元素的过程。
2.1 二分查找（Binary Search）
条件：数组必须有序。
原理：每次将搜索范围缩小一半。
时间复杂度：O(log n)
示例代码：
java
public class BinarySearch {
public static int search(int[] arr, int target) {
int left = 0, right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid; // 找到目标
} else if (arr[mid] < target) {
left = mid + 1; // 目标在右半部分
} else {
right = mid - 1; // 目标在左半部分
}
}
return -1; // 未找到
}
}- 递归与分治
递归是方法调用自身的技术，分治法是将问题分解为子问题。
3.1 斐波那契数列（Fibonacci）
问题：数列满足 F (n) = F (n-1) + F (n-2)，初始值 F (0)=0, F (1)=1。
递归实现：
java
public class Fibonacci {
public static int fib(int n) {
if (n <= 1) {
return n;
}
return fib(n - 1) + fib(n - 2);
}
}优化：使用迭代或记忆化（Memoization）避免重复计算。
- 动态规划（Dynamic Programming）
将复杂问题分解为重叠子问题，通过存储子问题的解避免重复计算。
4.1 爬楼梯问题
问题：每次可以爬 1 或 2 阶，求爬到第 n 阶的方法数。
状态转移方程：dp[i] = dp[i-1] + dp[i-2]
代码实现：
java
public class ClimbingStairs {
public static int climbStairs(int n) {
if (n <= 2) return n;
int[] dp = new int[n + 1];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
}- 回溯算法（Backtracking）
通过尝试所有可能的解决方案来找到问题的解，不满足条件时回退。
5.1 全排列问题
问题：生成数组的所有排列。
代码实现：
java
import java.util.ArrayList;
import java.util.List;
public class Permutations {
public static List<List<Integer>> permute(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
backtrack(result, new ArrayList<>(), nums);
return result;
}
private static void backtrack(List<List<Integer>> result, List<Integer> temp, int[] nums) {
if (temp.size() == nums.length) {
result.add(new ArrayList<>(temp));
} else {
for (int num : nums) {
if (temp.contains(num)) continue; // 跳过已选元素
temp.add(num);
backtrack(result, temp, nums);
temp.remove(temp.size() - 1); // 回溯
}
}
}
}- 贪心算法（Greedy Algorithm）
在每一步选择中都采取当前状态下的最优选择，期望导致全局最优解。
6.1 找零问题
问题：用最少的硬币找零。
代码实现：
java
public class CoinChange {
public static int greedyCoinChange(int amount, int[] coins) {
int count = 0;
for (int coin : coins) {
while (amount >= coin) {
amount -= coin;
count++;
}
}
return amount == 0 ? count : -1; // 无法找零
}
}- 图算法
处理图结构的算法，如最短路径、最小生成树等。
7.1 广度优先搜索（BFS）
用途：遍历或搜索树或图的算法，优先访问邻居节点。
代码实现：
java
import java.util.*;
public class BFS {
public static void bfs(Graph graph, int start) {
boolean[] visited = new boolean[graph.getVertices()];
Queue<Integer> queue = new LinkedList<>();
visited[start] = true;
queue.add(start);
while (!queue.isEmpty()) {
int vertex = queue.poll();
System.out.print(vertex + " ");
for (int neighbor : graph.getAdjacentVertices(vertex)) {
if (!visited[neighbor]) {
visited[neighbor] = true;
queue.add(neighbor);
}
}
}
}- 字符串匹配算法
在文本中查找模式串的出现位置。
8.1 KMP 算法
原理：利用已经匹配的部分信息，避免重复匹配。
时间复杂度：O (n + m)，n 为文本长度，m 为模式长度。
Java 内置算法工具类
Java 提供了多个工具类简化算法实现：
Arrays：排序、二分查找、填充等。
Collections：排序、查找、反转等。
PriorityQueue：优先队列（堆结构）。
HashMap/TreeMap：哈希表和有序映射。
常见算法面试题
两数之和：在数组中找到两个数的和等于目标值。
解法：使用哈希表，时间复杂度 O (n)。
反转链表：迭代或递归反转链表。
解法：迭代时维护前驱节点，递归时先反转后续节点。
二叉树遍历：前序、中序、后序、层序遍历。
解法：递归或迭代（层序用 BFS）。
合并两个有序数组：合并两个有序数组成一个新的有序数组。
解法：双指针从后向前遍历。
掌握这些算法的核心思想和实现方式，对解决实际问题和应对面试至关重要。