JAVASE:常见的算法

Java永无止境

于 2025-05-21 21:11:19 发布

阅读量800

点赞数 14

分类专栏： JAVASE 文章标签：算法排序算法数据结构 java 开发语言

本文链接：https://blog.csdn.net/2302_77351591/article/details/148124242

版权

JAVASE 专栏收录该内容

13 篇文章

订阅专栏

在 Java 中，算法是解决特定问题的一系列明确指令。以下是 Java 开发中常见的算法分类及示例：

排序算法
排序是将数据按特定顺序排列的过程。Java 提供了多种排序实现：
1.1 冒泡排序（Bubble Sort）
原理：重复比较相邻元素，若顺序错误则交换，直到整个数组有序。
时间复杂度：O(n²)
示例代码：

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. 搜索算法
搜索是在数据集合中查找特定元素的过程。
2.1 二分查找（Binary Search）
条件：数组必须有序。
原理：每次将搜索范围缩小一半。
时间复杂度：O(log n)
示例代码：

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。
递归实现：

public class Fibonacci {
    public static int fib(int n) {
        if (n <= 1) {
            return n;
        }
        return fib(n - 1) + fib(n - 2);
    }
}

优化：使用迭代或记忆化（Memoization）避免重复计算。
4. 动态规划（Dynamic Programming）
将复杂问题分解为重叠子问题，通过存储子问题的解避免重复计算。
4.1 爬楼梯问题
问题：每次可以爬 1 或 2 阶，求爬到第 n 阶的方法数。
状态转移方程：dp[i] = dp[i-1] + dp[i-2]
代码实现：

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 全排列问题
问题：生成数组的所有排列。
代码实现：

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 找零问题
问题：用最少的硬币找零。
代码实现：

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）
用途：遍历或搜索树或图的算法，优先访问邻居节点。
代码实现：

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）。
合并两个有序数组：合并两个有序数组成一个新的有序数组。
解法：双指针从后向前遍历。
掌握这些算法的核心思想和实现方式，对解决实际问题和应对面试至关重要。