1.3w字蓝桥杯知识点运用全攻略助力登顶！！！

一、集合框架的高效运用

1. 蓝桥杯中的集合框架考点

集合框架在蓝桥杯比赛中常见的题型包括数据处理（如统计数字频率、去重、排序等）、动态数据管理（如任务调度、模拟队列或栈操作）以及算法优化（如利用集合特性优化搜索或排序算法）。

2. 集合框架在比赛中的应用场景

• 统计数字频率：使用 HashMap 存储数字及其频率，遍历数组并更新频率。

import java.util.HashMap;
import java.util.Map;

public class FrequencyCount {
    public static void main(String[] args) {
        // 定义一个整数数组
        int[] nums = {1, 2, 2, 3, 3, 3};
        // 创建一个HashMap来存储数字及其出现的频率
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        
        // 遍历数组中的每个数字
        for (int num : nums) {
            // 使用getOrDefault方法获取当前数字的频率，若不存在则默认为0，然后加1
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }
        
        // 输出统计结果
        System.out.println(frequencyMap);
    }
}

解释：HashMap 是一个键值对的集合，它允许我们以键为索引快速存储和检索值。在这里，我们用数字作为键，数字出现的次数作为值。通过遍历数组，我们可以统计每个数字出现的频率。

• 去重与排序：使用 TreeSet 自动去重并排序。

import java.util.Set;
import java.util.TreeSet;

public class UniqueSortedStrings {
    public static void main(String[] args) {
        // 定义一个字符串数组
        String[] words = {"apple", "banana", "apple", "orange", "banana"};
        // 创建一个TreeSet来存储唯一的字符串
        Set<String> uniqueWords = new TreeSet<>();
        
        // 遍历数组中的每个字符串
        for (String word : words) {
            // 将字符串添加到TreeSet中，自动去重
            uniqueWords.add(word);
        }
        
        // 输出去重并排序后的结果
        System.out.println(uniqueWords);
    }
}

解释：TreeSet 是一个有序的集合，它不允许重复的元素。当我们向 TreeSet 中添加元素时，它会自动按照自然顺序（如字典序）进行排序，并且重复的元素会被自动忽略。

• 任务调度：使用 PriorityQueue 实现优先队列。

import java.util.PriorityQueue;

public class TaskScheduler {
    public static void main(String[] args) {
        // 创建一个优先队列，使用自定义的比较器，按照任务的优先级降序排列
        PriorityQueue<Integer> tasks = new PriorityQueue<>((a, b) -> b - a);
        // 向队列中添加任务
        tasks.add(5);
        tasks.add(1);
        tasks.add(10);
        
        // 处理任务，每次取出优先级最高的任务
        while (!tasks.isEmpty()) {
            System.out.println("Processing task: " + tasks.poll());
        }
    }
}

解释：PriorityQueue 是一个优先级队列，它根据元素的自然顺序或指定的比较器来对元素进行排序。在这个例子中，我们使用自定义的比较器来实现任务的优先级调度，优先级高的任务会先被处理。

3. 比赛中的优化技巧

• 选择合适的集合：需要快速查找时，优先选择 HashMap；需要排序时，选择 TreeSet 或 TreeMap；需要动态管理数据时，使用 ArrayList 或 LinkedList。
• 利用泛型提高代码安全性：在声明集合时，尽量使用泛型，避免运行时类型转换错误。

List<Integer> list = new ArrayList<>();

• 灵活使用集合工具类：Collections 类提供了丰富的工具方法，如排序、查找、反转等。

List<Integer> data = Arrays.asList(3, 1, 2);
Collections.sort(data); // 对集合进行排序
Collections.reverse(data); // 对集合进行反转

二、基础算法的深入理解与运用

排序算法

• 冒泡排序：通过相邻元素的比较和交换，将最大的元素逐步移动到数组末尾。适用于简单数组的排序问题。

public class BubbleSort {
    static 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;
                }
    }
}

解释：冒泡排序是一种简单的排序算法，它重复地遍历要排序的数组，比较每对相邻元素，如果它们的顺序错误就把它们交换过来。这个过程会重复进行，直到没有再需要交换的元素，说明数组已经排序完成。

• 选择排序：每次从未排序部分中选择最小值放到已排序部分的末尾。适用于找出数组中的最小或最大值并进行排序的情况。

public class SelectionSort {
    static 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;
        }
    }
}

解释：选择排序是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完为止。

• 插入排序：适用于数据量较小且基本有序的情况。将新元素插入到已排序序列中的适当位置。

public class InsertionSort {
    static 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;
        }
    }
}

解释：插入排序是一种简单直观的排序算法，它的工作原理是构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用就地排序（in-place），即只需用到O(1)的额外空间。

• 快速排序：选择一个基准元素，将数组分为小于基准和大于基准的两部分，递归排序这两部分。适用于大规模数据的排序问题。

public class QuickSort {
    static 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);
        }
    }
    
    static int partition(int[] arr, int low, int high) {
        // 选择最后一个元素作为基准
        int pivot = arr[high];
        // 初始化较小元素的索引
        int i = (low - 1);
        // 遍历数组，将小于基准的元素移到左边
        for (int j = low; j <= high - 1; 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;
    }
}

解释：快速排序是一种高效的排序算法，采用分治法的策略，将数组分为两部分，一部分比基准小，另一部分比基准大，然后递归地对这两部分进行快速排序。它的平均时间复杂度为O(n log n)，在实际应用中非常广泛。

• 归并排序：将数组分成两半，分别排序后再合并。适用于处理链表排序或需要稳定排序的场景。

public class MergeSort {
    static void mergeSort(int[] arr) {
        if (arr.length < 2) {
            return;
        }
        // 将数组分成两半
        int mid = arr.length / 2;
        int[] left = new int[mid];
        int[] right = new int[arr.length - mid];
        // 复制数组到左右两半
        for (int i = 0; i < mid; i++) {
            left[i] = arr[i];
        }
        for (int i = mid; i < arr.length; i++) {
            right[i - mid] = arr[i];
        }
        // 递归排序左右两半
        mergeSort(left);
        mergeSort(right);
        // 合并排序后的左右两半
        merge(arr, left, right);
    }
    
    static void merge(int[] arr, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        // 合并左右两半到原数组
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
            }
        }
        // 处理剩余元素
        while (i < left.length) {
            arr[k++] = left[i++];
        }
        while (j < right.length) {
            arr[k++] = right[j++];
        }
    }
}

解释：归并排序是一种采用分治法的排序算法，它将数组分成两半，分别排序后再合并成一个有序数组。归并排序的稳定性和时间复杂度使其在需要稳定排序的场景中非常有用。

• 堆排序：利用堆数据结构，通过建立最大堆或最小堆来排序。适用于需要原地排序且对时间复杂度有较高要求的情况。

public class HeapSort {
    static void heapSort(int[] arr) {
        int n = arr.length;
        // 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);
        // 依次取出堆顶元素，构建有序数组
        for (int i = n - 1; i >= 0; i--) {
            // 将堆顶元素移到数组末尾
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            // 调整堆结构
            heapify(arr, i, 0);
        }
    }
    
    static void heapify(int[] arr, int n, int i) {
        int largest = i; // 初始化最大值为当前节点
        int left = 2 * i + 1; // 左子节点
        int right = 2 * i + 2; // 右子节点
        
        // 如果左子节点存在且大于当前最大值
        if (left < n && arr[left] > arr[largest])
            largest = left;
        
        // 如果右子节点存在且大于当前最大值
        if (right < n && arr[right] > arr[largest])
            largest = right;
        
        // 如果最大值不是当前节点，则交换并递归调整
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }
}

解释：堆排序是一种基于堆数据结构的排序算法，它通过构建最大堆或最小堆来实现排序。堆排序的时间复杂度为O(n log n)，并且只需要常数级的额外空间，因此在需要原地排序的场景中非常有用。

查找算法

• 顺序查找：适用于数据量较小或无序的数据集合。逐个比较元素与目标值。

public class SequentialSearch {
    static int sequentialSearch(int[] arr, int target) {
        // 遍历数组中的每个元素
        for (int i = 0; i < arr.length; i++) {
            // 如果找到目标值，返回其索引
            if (arr[i] == target) {
                return i;
            }
        }
        // 如果未找到，返回-1
        return -1;
    }
}

解释：顺序查找是最简单的查找算法，它从数组的第一个元素开始，逐个比较元素与目标值，直到找到目标值或遍历完整个数组。

• 二分查找：适用于有序数组。通过将搜索范围逐步缩小一半来快速定位目标元素。

public class BinarySearch {
    static 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;
            }
        }
        // 如果未找到，返回-1
        return -1;
    }
}

解释：二分查找是一种高效的查找算法，它利用数组的有序性，通过不断将搜索范围缩小一半来快速定位目标元素。它的平均时间复杂度为O(log n)，在处理大规模数据时非常高效。

• 哈希查找：利用哈希表实现快速查找。适用于大数据量场景。

import java.util.HashMap;
import java.util.Map;

public class HashSearch {
    public static void main(String[] args) {
        // 创建一个HashMap来存储学生信息
        Map<String, Integer> studentMap = new HashMap<>();
        studentMap.put("Alice", 101);
        studentMap.put("Bob", 102);
        studentMap.put("Charlie", 103);
        // 定义要查找的目标学生
        String target = "Bob";
        // 如果学生存在，输出其ID
        if (studentMap.containsKey(target)) {
            System.out.println("Student found with ID: " + studentMap.get(target));
        } else {
            System.out.println("Student not found");
        }
    }
}

解释：哈希查找利用哈希表的数据结构，通过哈希函数将键映射到表中的位置，从而实现快速查找。哈希查找的平均时间复杂度为O(1)，在处理大数据量时具有明显优势。

字符串匹配算法

• 暴力匹配：适用于简单场景。逐个比较文本与模式串的字符。

public class BruteForceSearch {
    static int bruteForceSearch(String text, String pattern) {
        int n = text.length();
        int m = pattern.length();
        // 遍历文本中的每个可能的起始位置
        for (int i = 0; i <= n - m; i++) {
            int j;
            // 比较模式串中的每个字符
            for (j = 0; j < m; j++) {
                if (text.charAt(i + j) != pattern.charAt(j)) {
                    break;
                }
            }
            // 如果所有字符都匹配，返回起始位置
            if (j == m) {
                return i;
            }
        }
        // 如果未找到，返回-1
        return -1;
    }
}

解释：暴力匹配是最基础的字符串匹配算法，它通过逐个比较文本与模式串的字符来查找匹配位置。虽然实现简单，但在最坏情况下时间复杂度较高。

• KMP 算法：通过预处理模式串生成部分匹配表，减少不必要的比较。

public class KMPAlgorithm {
    static int[] computeLPSArray(String pattern) {
        int m = pattern.length();
        int[] lps = new int[m];
        int len = 0;
        int i = 1;
        // 计算部分匹配表
        while (i < m) {
            if (pattern.charAt(i) == pattern.charAt(len)) {
                len++;
                lps[i] = len;
                i++;
            } else {
                if (len != 0) {
                    len = lps[len - 1];
                } else {
                    lps[i] = 0;
                    i++;
                }
            }
        }
        return lps;
    }
    
    static int kmpSearch(String text, String pattern, int[] lps) {
        int n = text.length();
        int m = pattern.length();
        int i = 0; // 文本的索引
        int j = 0; // 模式的索引
        // 遍历文本
        while (i < n) {
            // 如果当前字符匹配，继续比较下一个字符
            if (pattern.charAt(j) == text.charAt(i)) {
                i++;
                j++;
            }
            // 如果模式串的字符匹配完成，返回匹配位置
            if (j == m) {
                return i - j;
            } 
            // 如果当前字符不匹配，调整模式串的起始位置
            else if (i < n && pattern.charAt(j) != text.charAt(i)) {
                if (j != 0) {
                    j = lps[j - 1];
                } else {
                    i++;
                }
            }
        }
        // 如果未找到，返回-1
        return -1;
    }
}

解释：KMP 算法通过预处理模式串生成部分匹配表，从而在匹配过程中避免不必要的回溯，提高了匹配效率。它特别适用于处理较长的文本和模式串。

• Boyer-Moore 算法：从模式串末尾开始匹配，利用坏字符规则和好后缀规则提高效率。

public class BoyerMooreAlgorithm {
    static int boyerMooreSearch(String text, String pattern) {
        int n = text.length();
        int m = pattern.length();
        // 初始化坏字符表
        int[] badChar = new int[256];
        for (int i = 0; i < 256; i++) {
            badChar[i] = m;
        }
        for (int i = 0; i < m; i++) {
            badChar[pattern.charAt(i)] = m - i - 1;
        }
        int s = 0; // 模式串在文本中的起始位置
        // 遍历文本
        while (s <= n - m) {
            int j = m - 1;
            // 从后向前比较模式串和文本的字符
            while (j >= 0 && pattern.charAt(j) == text.charAt(s + j)) {
                j--;
            }
            // 如果所有字符都匹配，返回匹配位置
            if (j < 0) {
                return s;
            } else {
                // 根据坏字符规则调整起始位置
                s += badChar[text.charAt(s + j)];
            }
        }
        // 如果未找到，返回-1
        return -1;
    }
}

解释：Boyer-Moore 算法通过从模式串的末尾开始匹配，并利用坏字符规则和好后缀规则来跳过不可能匹配的文本部分，从而提高匹配效率。它在实际应用中通常比 KMP 算法更快。

图论算法

• 最短路径算法：

• • Dijkstra 算法：适用于非负权图。通过维护一个优先队列来选择当前距离最小的顶点进行扩展。

import java.util.PriorityQueue;

public class DijkstraAlgorithm {
    static int[] dijkstra(int[][] graph, int startVertex) {
        int n = graph.length;
        int[] distances = new int[n];
        boolean[] visited = new boolean[n];
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        // 初始化距离数组为无穷大
        for (int i = 0; i < n; i++) {
            distances[i] = Integer.MAX_VALUE;
        }
        // 起始顶点的距离为0
        distances[startVertex] = 0;
        priorityQueue.add(startVertex);
        // 处理优先队列中的顶点
        while (!priorityQueue.isEmpty()) {
            int u = priorityQueue.poll();
            if (visited[u]) continue;
            visited[u] = true;
            // 遍历当前顶点的所有邻接顶点
            for (int v = 0; v < n; v++) {
                if (graph[u][v] != 0 && !visited[v] && distances[u] + graph[u][v] < distances[v]) {
                    distances[v] = distances[u] + graph[u][v];
                    priorityQueue.add(v);
                }
            }
        }
        return distances;
    }
}

解释：Dijkstra 算法是一种用于寻找图中单源最短路径的算法，它适用于所有边权非负的图。算法通过维护一个优先队列来选择当前距离最小的顶点进行扩展，逐步构建最短路径树。

• • Floyd-Warshall 算法：适用于任意权图，能求出所有顶点对之间的最短路径。通过动态规划的思想，逐步尝试通过中间顶点来优化路径。

public class FloydWarshallAlgorithm {
    static final int INF = Integer.MAX_VALUE / 3;
    static int[][] floydWarshall(int[][] graph) {
        int n = graph.length;
        int[][] distances = new int[n][n];
        // 初始化距离矩阵
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                distances[i][j] = graph[i][j];
            }
        }
        // 动态规划计算最短路径
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (distances[i][k] != INF && distances[k][j] != INF && distances[i][k] + distances[k][j] < distances[i][j]) {
                        distances[i][j] = distances[i][k] + distances[k][j];
                    }
                }
            }
        }
        return distances;
    }
}

解释：Floyd-Warshall 算法是一种用于寻找图中所有顶点对之间最短路径的算法，它适用于任意权图。算法通过动态规划的思想，逐步尝试通过中间顶点来优化路径，最终得到所有顶点对之间的最短路径。

• 最小生成树算法：

• • Kruskal 算法：通过将边按权重从小到大排序，逐步选择不构成环的最小边来构建最小生成树。

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

class Edge implements Comparable<Edge> {
    int src, dest, weight;
    Edge(int src, int dest, int weight) {
        this.src = src;
        this.dest = dest;
        this.weight = weight;
    }
    @Override
    public int compareTo(Edge other) {
        return this.weight - other.weight;
    }
}

class Subset {
    int parent, rank;
}

public class KruskalAlgorithm {
    static Edge[] kruskalMST(List<Edge> edges, int V) {
        Collections.sort(edges);
        Subset[] subsets = new Subset[V];
        for (int v = 0; v < V; v++) {
            subsets[v] = new Subset();
            subsets[v].parent = v;
            subsets[v].rank = 0;
        }
        Edge[] result = new Edge[V - 1];
        int e = 0;
        int i = 0;
        while (e < V - 1) {
            Edge nextEdge = edges.get(i++);
            int x = find(subsets, nextEdge.src);
            int y = find(subsets, nextEdge.dest);
            if (x != y) {
                result[e++] = nextEdge;
                union(subsets, x, y);
            }
        }
        return result;
    }
    static int find(Subset[] subsets, int i) {
        if (subsets[i].parent != i) {
            subsets[i].parent = find(subsets, subsets[i].parent);
        }
        return subsets[i].parent;
    }
    static void union(Subset[] subsets, int x, int y) {
        int xroot = find(subsets, x);
        int yroot = find(subsets, y);
        if (subsets[xroot].rank < subsets[yroot].rank) {
            subsets[xroot].parent = yroot;
        } else if (subsets[xroot].rank > subsets[yroot].rank) {
            subsets[yroot].parent = xroot;
        } else {
            subsets[yroot].parent = xroot;
            subsets[xroot].rank++;
        }
    }
}

解释：Kruskal 算法是一种用于寻找图中最小生成树的算法，它通过将边按权重从小到大排序，逐步选择不构成环的最小边来构建最小生成树。算法利用并查集数据结构来高效地检测环。

• • Prim 算法：通过维护一个最小堆来选择当前最小权重的边，逐步构建最小生成树。

public class PrimAlgorithm {
    static int[] primMST(int[][] graph, int startVertex) {
        int V = graph.length;
        int[] parent = new int[V];
        int[] key = new int[V];
        boolean[] mstSet = new boolean[V];
        for (int i = 0; i < V; i++) {
            key[i] = Integer.MAX_VALUE;
            mstSet[i] = false;
        }
        key[startVertex] = 0;
        parent[startVertex] = -1;
        for (int count = 0; count < V - 1; count++) {
            int u = minKey(key, mstSet);
            mstSet[u] = true;
            for (int v = 0; v < V; v++) {
                if (graph[u][v] != 0 && !mstSet[v] && graph[u][v] < key[v]) {
                    parent[v] = u;
                    key[v] = graph[u][v];
                }
            }
        }
        return parent;
    }
    static int minKey(int[] key, boolean[] mstSet) {
        int min = Integer.MAX_VALUE;
        int minIndex = -1;
        for (int v = 0; v < key.length; v++) {
            if (!mstSet[v] && key[v] < min) {
                min = key[v];
                minIndex = v;
            }
        }
        return minIndex;
    }
}

解释：Prim 算法是一种用于寻找图中最小生成树的算法，它通过维护一个最小堆来选择当前最小权重的边，逐步构建最小生成树。算法从一个起始顶点开始，逐步扩展到其他顶点，直到所有顶点都被包含在生成树中。

• 拓扑排序：适用于有向无环图，通过维护一个入度为0的顶点队列，逐步输出顶点并减少相邻顶点的入度来实现。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class TopologicalSort {
    static void addEdge(List<List<Integer>> adj, int u, int v) {
        adj.get(u).add(v);
    }
    static void topologicalSort(List<List<Integer>> adj, int V) {
        int[] inDegree = new int[V];
        for (int i = 0; i < V; i++) {
            for (int node : adj.get(i)) {
                inDegree[node]++;
            }
        }
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < V; i++) {
            if (inDegree[i] == 0) {
                queue.add(i);
            }
        }
        List<Integer> topOrder = new ArrayList<>();
        while (!queue.isEmpty()) {
            int u = queue.poll();
            topOrder.add(u);
            for (int v : adj.get(u)) {
                if (--inDegree[v] == 0) {
                    queue.add(v);
                }
            }
        }
        if (topOrder.size() != V) {
            System.out.println("There exists a cycle in the graph");
        } else {
            System.out.println("Topological Sort Order:");
            for (int node : topOrder) {
                System.out.print(node + " ");
            }
        }
    }
}

解释：拓扑排序是一种针对有向无环图的排序算法，它将图中的顶点按照线性顺序排列，使得对于每一条有向边(u, v)，顶点u在线性顺序中都出现在顶点v之前。拓扑排序在任务调度、依赖关系处理等场景中非常有用。

递归与分治算法

• 递归：适用于解决分形问题、汉诺塔问题等。通过将问题分解为更小的子问题来逐步求解。

public class TowerOfHanoi {
    static void towerOfHanoi(int n, char source, char destination, char auxiliary) {
        if (n == 1) {
            System.out.println("Move disk 1 from " + source + " to " + destination);
            return;
        }
        // 将n-1个盘子从源柱移动到辅助柱
        towerOfHanoi(n - 1, source, auxiliary, destination);
        // 将第n个盘子从源柱移动到目标柱
        System.out.println("Move disk " + n + " from " + source + " to " + destination);
        // 将n-1个盘子从辅助柱移动到目标柱
        towerOfHanoi(n - 1, auxiliary, destination, source);
    }
}

解释：递归是一种通过函数调用自身来解决问题的编程技术。在汉诺塔问题中，我们通过将问题分解为将n-1个盘子移动到辅助柱，然后将第n个盘子移动到目标柱，最后将n-1个盘子从辅助柱移动到目标柱，从而实现递归求解。

• 分治：适用于大规模数据处理、复杂问题求解等场景。将问题分解为多个子问题，分别求解后再合并结果。

public class DivideAndConquer {
    static String addStrings(String num1, String num2) {
        int i = num1.length() - 1;
        int j = num2.length() - 1;
        int carry = 0;
        StringBuilder sb = new StringBuilder();
        // 从右向左逐位相加
        while (i >= 0 || j >= 0 || carry > 0) {
            int digit1 = (i >= 0) ? num1.charAt(i--) - '0' : 0;
            int digit2 = (j >= 0) ? num2.charAt(j--) - '0' : 0;
            int sum = digit1 + digit2 + carry;
            carry = sum / 10;
            sb.append(sum % 10);
        }
        // 反转结果字符串
        return sb.reverse().toString();
    }
}

解释：分治算法是一种将问题分解为多个子问题分别求解，然后将子问题的解合并得到原问题的解的算法设计策略。在大数相加问题中，我们将两个大数从右向左逐位相加，并处理进位，最后将结果反转得到正确的和。

三、总结

在蓝桥杯 Java 组比赛中，熟练掌握集合框架、排序算法、查找算法、字符串匹配算法、图论算法以及递归与分治算法等知识点，并能够灵活运用到实际问题中，是取得优异成绩的关键。通过本文的讲解和示例代码，希望你能更好地理解和运用这些知识点，为参赛做好充分准备。祝你在蓝桥杯大赛中取得理想的成绩！