Java常用算法

一、排序算法

排序算法是计算机科学中最基础的算法之一，用于将一组数据按照特定顺序排列。

1.1 冒泡排序（Bubble Sort）

通过重复遍历列表，比较相邻元素并交换位置，直到列表有序。
时间复杂度：O(n²)。

public void bubbleSort(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 选择排序（Selection Sort）

每次从未排序部分选择最小元素，放到已排序部分的末尾。
时间复杂度：O(n²)。

public void selectionSort(int[] arr) {int n = arr.length;for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}int temp = arr[minIndex];arr[minIndex] = arr[i];arr[i] = temp;}
}

1.3 插入排序（Insertion Sort）

将未排序部分的元素逐个插入到已排序部分的适当位置。
时间复杂度：O(n²)。

public void insertionSort(int[] arr) {int n = arr.length;for (int i = 1; i < n; i++) {int key = arr[i];int j = i - 1;while (j >= 0 && arr[j] > key) {arr[j+1] = arr[j];j = j - 1;}arr[j+1] = key;}
}

1.4 快速排序（Quick Sort）

采用分治法，选择一个基准元素，将数组分为两部分，递归排序。
时间复杂度：平均 O(n log n)，最坏 O(n²)。

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;
}

1.5 归并排序（Merge Sort）

采用分治法，将数组分为两半，分别排序后合并。
时间复杂度：O(n log n)。

public void mergeSort(int[] arr, int l, int r) {if (l < r) {int m = (l + r) / 2;mergeSort(arr, l, m);mergeSort(arr, m+1, r);merge(arr, l, m, r);}
}private void merge(int[] arr, int l, int m, int r) {int n1 = m - l + 1;int n2 = r - m;int[] L = new int[n1];int[] R = new int[n2];for (int i = 0; i < n1; i++) {L[i] = arr[l + i];}for (int j = 0; j < n2; j++) {R[j] = arr[m + 1 + j];}int i = 0, j = 0;int k = l;while (i < n1 && j < n2) {if (L[i] <= R[j]) {arr[k] = L[i];i++;} else {arr[k] = R[j];j++;}k++;}while (i < n1) {arr[k] = L[i];i++;k++;}while (j < n2) {arr[k] = R[j];j++;k++;}
}

二、查找算法

查找算法用于在数据结构中查找特定元素。常见的查找算法包括：

2.1 线性查找（Linear Search）

逐个检查每个元素，直到找到目标元素。
时间复杂度：O(n)。

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 二分查找（Binary Search）

适用于已排序的数组，通过重复将搜索范围减半来查找目标元素。
时间复杂度：O(log n)。

public int binarySearch(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 深度优先搜索（DFS）

从起始节点开始，沿着一条路径尽可能深入，直到无法继续为止，然后回溯。

public void dfs(int[][] graph, int start, boolean[] visited) {visited[start] = true;System.out.print(start + " ");for (int i = 0; i < graph[start].length; i++) {int next = graph[start][i];if (!visited[next]) {dfs(graph, next, visited);}}
}

3.2 广度优先搜索（BFS）

从起始节点开始，逐层遍历所有相邻节点。

public void bfs(int[][] graph, int start) {boolean[] visited = new boolean[graph.length];Queue<Integer> queue = new LinkedList<>();visited[start] = true;queue.add(start);while (!queue.isEmpty()) {int node = queue.poll();System.out.print(node + " ");for (int i = 0; i < graph[node].length; i++) {int next = graph[node][i];if (!visited[next]) {visited[next] = true;queue.add(next);}}}
}

3.3 Dijkstra 算法

用于计算单源最短路径，适用于加权图。

public void dijkstra(int[][] graph, int start) {int n = graph.length;int[] dist = new int[n];boolean[] visited = new boolean[n];Arrays.fill(dist, Integer.MAX_VALUE);dist[start] = 0;for (int i = 0; i < n-1; i++) {int u = minDistance(dist, visited);visited[u] = true;for (int v = 0; v < n; v++) {if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) {dist[v] = dist[u] + graph[u][v];}}}printSolution(dist);
}private int minDistance(int[] dist, boolean[] visited) {int min = Integer.MAX_VALUE, minIndex = -1;for (int i = 0; i < dist.length; i++) {if (!visited[i] && dist[i] <= min) {min = dist[i];minIndex = i;}}return minIndex;
}private void printSolution(int[] dist) {System.out.println("Vertex \t Distance from Source");for (int i = 0; i < dist.length; i++) {System.out.println(i + " \t\t " + dist[i]);}
}

四、动态规划

动态规划用于解决具有重叠子问题和最优子结构性质的问题。常见的动态规划问题包括：

4.1 斐波那契数列

使用动态规划计算斐波那契数列的第 n 项。

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];
}

4.2 背包问题

解决 0-1 背包问题，即在给定容量下选择物品使总价值最大。

public int knapsack(int[] weights, int[] values, int capacity) {int n = weights.length;int[][] dp = new int[n+1][capacity+1];for (int i = 1; i <= n; i++) {for (int j = 0; j <= capacity; j++) {if (weights[i-1] <= j) {dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weights[i-1]] + values[i-1]);} else {dp[i][j] = dp[i-1][j];}}}return dp[n][capacity];
}

五、贪心算法

贪心算法在每一步选择中都采取当前状态下最优的选择，希望导致全局最优解。常见的贪心算法问题包括：

5.1 活动选择问题

选择最大数量的互不重叠的活动。

public int activitySelection(int[] start, int[] end) {Arrays.sort(end);int count = 1;int lastEnd = end[0];for (int i = 1; i < end.length; i++) {if (start[i] >= lastEnd) {count++;lastEnd = end[i];}}return count;
}

六、回溯算法

回溯算法通过尝试所有可能的解来解决问题，通常用于组合、排列等问题。常见的回溯算法问题包括：

6.1 N 皇后问题

在 N×N 棋盘上放置 N 个皇后，使其互不攻击。

public void solveNQueens(int n) {int[] queens = new int[n];Arrays.fill(queens, -1);backtrack(queens, 0, n);
}private void backtrack(int[] queens, int row, int n) {if (row == n) {printQueens(queens);return;}for (int col = 0; col < n; col++) {if (isSafe(queens, row, col)) {queens[row] = col;backtrack(queens, row+1, n);queens[row] = -1;}}
}private boolean isSafe(int[] queens, int row, int col) {for (int i = 0; i < row; i++) {if (queens[i] == col || Math.abs(queens[i] - col) == Math.abs(i - row)) {return false;}}return true;
}private void printQueens(int[] queens) {for (int i = 0; i < queens.length; i++) {for (int j = 0; j < queens.length; j++) {if (queens[i] == j) {System.out.print("Q ");} else {System.out.print(". ");}}System.out.println();}System.out.println();
}

七、字符串匹配算法

字符串匹配算法用于在文本中查找特定模式的子串。常见的字符串匹配算法包括：

7.1 KMP 算法

通过预处理模式串，避免不必要的比较。

public int kmpSearch(String text, String pattern) {int[] lps = computeLPSArray(pattern);int i = 0, j = 0;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 int[] computeLPSArray(String pattern) {int[] lps = new int[pattern.length()];int len = 0, i = 1;while (i < pattern.length()) {if (pattern.charAt(i) == pattern.charAt(len)) {len++;lps[i] = len;i++;} else {if (len != 0) {len = lps[len-1];} else {lps[i] = len;i++;}}}return lps;
}

八、数论算法

数论算法用于解决与整数相关的数学问题。常见的数论算法包括：

8.1 欧几里得算法

用于计算两个整数的最大公约数（GCD）。

public int gcd(int a, int b) {if (b == 0) {return a;}return gcd(b, a % b);
}

8.2 素数检测

判断一个数是否为素数。

public boolean isPrime(int n) {if (n <= 1) {return false;}for (int i = 2; i * i <= n; i++) {if (n % i == 0) {return false;}}return true;
}

九、位运算算法

位运算算法利用位操作来高效解决问题。常见的位运算算法包括：

9.1 计算二进制中 1 的个数

使用位运算计算一个整数的二进制表示中 1 的个数。

public int countSetBits(int n) {int count = 0;while (n > 0) {count += n & 1;n >>= 1;}return count;
}

9.2 判断一个数是否是 2 的幂

使用位运算判断一个数是否是 2 的幂。

public boolean isPowerOfTwo(int n) {return n > 0 && (n & (n - 1)) == 0;
}