Java算法与数据结构实现：从理论到实践的完整指南
项目地址: https://gitcode.com/gh_mirrors/ja/java-algorithms-implementation 还在为算法面试而苦恼？面对复杂的数据结构问题无从下手？本文将带你深入探索Java算法与数据结构的完整实现，提供从基础到高级的全面解决方案。
读完本文，你将获得：
- ✅ 20+核心数据结构的Java实现详解
- ✅ 30+经典算法的完整代码示例
- ✅ 算法复杂度分析与性能对比
- ✅ 实际应用场景与最佳实践
- ✅ 测试用例与调试技巧
📊 项目概览与架构设计
Java Algorithms Implementation是一个全面的算法和数据结构库，涵盖了从基础到高级的各类实现。项目采用模块化设计，每个算法和数据结构都有独立的实现和测试。
项目结构总览
🌳 核心数据结构实现
二叉搜索树（Binary Search Tree）
二叉搜索树是最基础且重要的树形数据结构，具有以下特性：
- 左子树所有节点的值小于根节点
- 右子树所有节点的值大于根节点
- 左右子树也都是二叉搜索树
Java实现核心代码
public class BinarySearchTree<T extends Comparable<T>> implements ITree<T> {
protected Node<T> root = null;
protected int size = 0;
// 节点插入算法
protected Node<T> addValue(T value) {
Node<T> newNode = this.creator.createNewNode(null, value);
if (root == null) {
root = newNode;
size++;
return newNode;
}
Node<T> node = root;
while (node != null) {
if (newNode.id.compareTo(node.id) <= 0) {
if (node.lesser == null) {
node.lesser = newNode;
newNode.parent = node;
size++;
return newNode;
}
node = node.lesser;
} else {
if (node.greater == null) {
node.greater = newNode;
newNode.parent = node;
size++;
return newNode;
}
node = node.greater;
}
}
return newNode;
}
}
复杂度分析表
| 操作 | 平均情况 | 最坏情况 | 空间复杂度 |
|---|---|---|---|
| 插入 | O(log n) | O(n) | O(n) |
| 搜索 | O(log n) | O(n) | O(1) |
| 删除 | O(log n) | O(n) | O(1) |
平衡树结构对比
🔄 排序算法深度解析
快速排序（QuickSort）实现
快速排序是实践中最高效的排序算法之一，采用分治策略。
核心实现代码
public class QuickSort<T extends Comparable<T>> {
public static <T extends Comparable<T>> T[] sort(PIVOT_TYPE pivotType, T[] unsorted) {
int pivot = 0;
if (pivotType == PIVOT_TYPE.MIDDLE) {
pivot = unsorted.length/2;
} else if (pivotType == PIVOT_TYPE.RANDOM) {
pivot = getRandom(unsorted.length);
}
sort(pivot, 0, unsorted.length - 1, unsorted);
return unsorted;
}
private static <T extends Comparable<T>> void sort(int index, int start, int finish, T[] unsorted) {
int pivotIndex = start + index;
T pivot = unsorted[pivotIndex];
int s = start;
int f = finish;
while (s <= f) {
while (unsorted[s].compareTo(pivot) < 0) s++;
while (unsorted[f].compareTo(pivot) > 0) f--;
if (s <= f) {
swap(s, f, unsorted);
s++;
f--;
}
}
if (start < f) sort(getRandom((f - start) + 1), start, f, unsorted);
if (s < finish) sort(getRandom((finish - s) + 1), s, finish, unsorted);
}
}
排序算法性能对比
| 算法 | 平均时间复杂度 | 最坏情况 | 空间复杂度 | 稳定性 | 适用场景 |
|---|---|---|---|---|---|
| 快速排序 | O(n log n) | O(n²) | O(log n) | 不稳定 | 通用排序 |
| 归并排序 | O(n log n) | O(n log n) | O(n) | 稳定 | 大数据量 |
| 堆排序 | O(n log n) | O(n log n) | O(1) | 不稳定 | 内存受限 |
| 插入排序 | O(n²) | O(n²) | O(1) | 稳定 | 小数据量 |
🗺️ 图算法实战应用
Dijkstra最短路径算法
Dijkstra算法用于在非负权图中寻找单源最短路径，是图论中的经典算法。
算法实现核心
public class Dijkstra {
public static Graph.CostPathPair<Integer> getShortestPath(Graph<Integer> graph,
Graph.Vertex<Integer> start,
Graph.Vertex<Integer> end) {
// 检查负权边
final boolean hasNegativeEdge = checkForNegativeEdges(graph.getVertices());
if (hasNegativeEdge) throw new IllegalArgumentException("Negative cost Edges are not allowed.");
final Map<Graph.Vertex<Integer>, List<Graph.Edge<Integer>>> paths = new HashMap<>();
final Map<Graph.Vertex<Integer>, Graph.CostVertexPair<Integer>> costs = new HashMap<>();
// 初始化成本表
for (Graph.Vertex<Integer> v : graph.getVertices()) {
if (v.equals(start)) costs.put(v, new Graph.CostVertexPair<Integer>(0, v));
else costs.put(v, new Graph.CostVertexPair<Integer>(Integer.MAX_VALUE, v));
}
final Queue<Graph.CostVertexPair<Integer>> unvisited = new PriorityQueue<>();
unvisited.add(costs.get(start));
while (!unvisited.isEmpty()) {
final Graph.CostVertexPair<Integer> pair = unvisited.remove();
final Graph.Vertex<Integer> vertex = pair.getVertex();
// 更新相邻顶点的最短路径
for (Graph.Edge<Integer> e : vertex.getEdges()) {
final Graph.CostVertexPair<Integer> toPair = costs.get(e.getToVertex());
final int cost = pair.getCost() + e.getCost();
if (cost < toPair.getCost()) {
unvisited.remove(toPair);
toPair.setCost(cost);
unvisited.add(toPair);
// 更新路径
List<Graph.Edge<Integer>> set = paths.get(e.getToVertex());
set.clear();
set.addAll(paths.get(e.getFromVertex()));
set.add(e);
}
}
}
return new Graph.CostPathPair<Integer>(costs.get(end).getCost(), paths.get(end));
}
}
图算法应用场景
🧮 数学算法与数值计算
快速幂算法实现
快速幂算法用于高效计算大数幂运算，时间复杂度为O(log n)。
public class Exponentiation {
// 快速幂算法 - 递归实现
public static long recursiveExponentiation(long x, long n) {
if (n == 0) return 1;
if (n == 1) return x;
if (n % 2 == 0) {
long half = recursiveExponentiation(x, n/2);
return half * half;
} else {
long half = recursiveExponentiation(x, (n-1)/2);
return half * half * x;
}
}
// 快速幂算法 - 迭代实现
public static long fastRecursiveExponentiation(long x, long n) {
long result = 1;
while (n > 0) {
if (n % 2 == 1) result *= x;
x *= x;
n /= 2;
}
return result;
}
}
模运算与数论算法
public class Modular {
// 模加法
public static long add(long a, long b, long mod) {
return (a % mod + b % mod) % mod;
}
// 模乘法
public static long multiply(long a, long b, long mod) {
long result = 0;
a = a % mod;
while (b > 0) {
if (b % 2 == 1) result = (result + a) % mod;
a = (a * 2) % mod;
b /= 2;
}
return result;
}
// 模幂运算 - 用于RSA加密等场景
public static long power(long base, long exponent, long mod) {
long result = 1;
base = base % mod;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % mod;
exponent = exponent >> 1;
base = (base * base) % mod;
}
return result;
}
}
🔍 搜索算法优化策略
二分搜索变体实现
public class BinarySearch {
// 标准二分搜索
public static <T extends Comparable<T>> int indexOf(T[] array, T value) {
int low = 0;
int high = array.length - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int cmp = array[mid].compareTo(value);
if (cmp < 0) low = mid + 1;
else if (cmp > 0) high = mid - 1;
else return mid;
}
return -1;
}
// 下界搜索 - 第一个大于等于目标的位置
public static <T extends Comparable<T>> int lowerBound(T[] array, T value) {
int low = 0;
int high = array.length;
while (low < high) {
int mid = (low + high) >>> 1;
if (array[mid].compareTo(value) < 0) low = mid + 1;
else high = mid;
}
return low;
}
// 上界搜索 - 第一个大于目标的位置
public static <T extends Comparable<T>> int upperBound(T[] array, T value) {
int low = 0;
int high = array.length;
while (low < high) {
int mid = (low + high) >>> 1;
if (array[mid].compareTo(value) <= 0) low = mid + 1;
else high = mid;
}
return low;
}
}
📝 字符串算法精要
KMP字符串匹配算法
Knuth-Morris-Pratt算法通过预处理模式串来优化字符串匹配效率。
public class KnuthMorrisPratt {
public static int indexOf(String text, String pattern) {
if (pattern.length() == 0) return 0;
if (text.length() == 0) return -1;
int[] lps = computeLPSArray(pattern);
int i = 0; // text索引
int j = 0; // pattern索引
while (i < text.length()) {
if (pattern.charAt(j) == text.charAt(i)) {
i++;
j++;
}
if (j == pattern.length()) {
return i - j; // 找到匹配
} else if (i < text.length() && pattern.charAt(j) != text.charAt(i)) {
if (j != 0) j = lps[j - 1];
else i++;
}
}
return -1;
}
// 计算最长前缀后缀数组
private static int[] computeLPSArray(String pattern) {
int[] lps = new int[pattern.length()];
int length = 0;
int i = 1;
while (i < pattern.length()) {
if (pattern.charAt(i) == pattern.charAt(length)) {
length++;
lps[i] = length;
i++;
} else {
if (length != 0) length = lps[length - 1];
else {
lps[i] = 0;
i++;
}
}
}
return lps;
}
}
🧪 测试与性能优化
算法性能测试框架
public class AlgorithmBenchmark {
public static void benchmarkSortingAlgorithms() {
int[] sizes = {1000, 10000, 100000};
String[] algorithms = {"QuickSort", "MergeSort", "HeapSort", "Arrays.sort"};
System.out.println("排序算法性能对比 (时间单位: 毫秒)");
System.out.println("==========================================");
System.out.printf("%-12s", "数据规模");
for (String algo : algorithms) {
System.out.printf("%-15s", algo);
}
System.out.println();
for (int size : sizes) {
Integer[] array = generateRandomArray(size);
System.out.printf("%-12d", size);
// 测试每个算法
for (String algo : algorithms) {
Integer[] testArray = array.clone();
long startTime = System.nanoTime();
switch (algo) {
case "QuickSort":
QuickSort.sort(QuickSort.PIVOT_TYPE.RANDOM, testArray);
break;
case "MergeSort":
MergeSort.sort(testArray);
break;
// 其他算法测试...
}
long endTime = System.nanoTime();
double duration = (endTime - startTime) / 1_000_000.0;
System.out.printf("%-15.3f", duration);
}
System.out.println();
}
}
private static Integer[] generateRandomArray(int size) {
Integer[] array = new Integer[size];
Random random = new Random();
for (int i = 0; i < size; i++) {
array[i] = random.nextInt(size * 10);
}
return array;
}
}
🎯 实际应用场景与最佳实践
场景1：数据库索引优化
二叉搜索树和B树在数据库索引中广泛应用：
// 数据库索引模拟实现
public class DatabaseIndex<T extends Comparable<T>> {
private BTree<T, Long> index; // B树作为索引结构
private Map<Long, String> dataStore; // 实际数据存储
public DatabaseIndex(int order) {
this.index = new BTree<>(order);
this.dataStore = new HashMap<>();
}
public void insert(T key, String value) {
Long recordId = System.currentTimeMillis();
index.insert(key, recordId);
dataStore.put(recordId, value);
}
public String search(T key) {
Long recordId = index.search(key);
return recordId != null ? dataStore.get(recordId) : null;
}
}
场景2：网络路由算法
Dijkstra算法在网络路由协议中的应用：
public class NetworkRouter {
private Graph<String> networkTopology;
public NetworkRouter() {
this.networkTopology = new Graph<>(true); // 有向图
}
public void addConnection(String from, String to, int cost) {
networkTopology.addEdge(from, to, cost);
}
public List<String> findShortestPath(String source, String destination) {
Graph.CostPathPair<Integer> path = Dijkstra.getShortestPath(
networkTopology,
new Graph.Vertex<>(source),
new Graph.Vertex<>(destination)
);
return path != null ? extractVertexPath(path.getPath()) : Collections.emptyList();
}
}
📊 算法选择指南
根据问题特点选择合适算法
mindmap
root((算法选择指南))创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
