Android学习总结之算法篇三（排序）

归并排序原理

归并排序（Merge Sort）是一种采用分治法（Divide and Conquer）的排序算法，其基本思想是将一个大问题分解为多个小问题，分别解决这些小问题，然后将小问题的解合并起来得到原问题的解。具体步骤如下：

分解（Divide）：将待排序的数组从中间分成两个子数组，递归地对这两个子数组继续进行分解，直到每个子数组中只有一个元素（因为单个元素的数组本身就是有序的）。
解决（Conquer）：对每个子数组进行排序，由于每个子数组只有一个元素，所以这一步实际上已经完成了排序。
合并（Merge）：将两个已排序的子数组合并成一个新的有序数组。重复这个合并过程，直到所有的子数组合并成一个完整的有序数组。

代码实现及注释

下面是用 Java 实现的归并排序代码，并带有详细的注释：

public class MergeSort {// 归并排序的主函数public static void mergeSort(int[] arr) {if (arr == null || arr.length <= 1) {return; // 如果数组为空或只有一个元素，无需排序}int[] temp = new int[arr.length]; // 创建一个临时数组，用于合并过程mergeSort(arr, 0, arr.length - 1, temp);}// 递归进行归并排序private static void mergeSort(int[] arr, int left, int right, int[] temp) {if (left < right) {int mid = left + (right - left) / 2; // 计算中间位置// 递归排序左半部分mergeSort(arr, left, mid, temp);// 递归排序右半部分mergeSort(arr, mid + 1, right, temp);// 合并两个已排序的子数组merge(arr, left, mid, right, temp);}}// 合并两个已排序的子数组private static void merge(int[] arr, int left, int mid, int right, int[] temp) {int i = left; // 左子数组的起始索引int j = mid + 1; // 右子数组的起始索引int k = left; // 临时数组的起始索引// 比较左右子数组的元素，将较小的元素放入临时数组while (i <= mid && j <= right) {if (arr[i] <= arr[j]) {temp[k++] = arr[i++];} else {temp[k++] = arr[j++];}}// 将左子数组中剩余的元素复制到临时数组while (i <= mid) {temp[k++] = arr[i++];}// 将右子数组中剩余的元素复制到临时数组while (j <= right) {temp[k++] = arr[j++];}// 将临时数组中的元素复制回原数组for (k = left; k <= right; k++) {arr[k] = temp[k];}}public static void main(String[] args) {int[] arr = {9, 5, 7, 1, 3, 8, 4, 2, 6};mergeSort(arr);for (int num : arr) {System.out.print(num + " ");}}
}

100000个数字中，对前10000小的数字进行排序（堆排）

import java.util.Arrays;
import java.util.PriorityQueue;public class SortTop10000Smallest {/*** 从给定的数字数组中找出前 10000 小的数字** @param numbers 包含 100000 个数字的数组* @return 包含前 10000 小数字的数组*/public static int[] getTop10000Smallest(int[] numbers) {// 创建一个最大堆，堆的大小为 10000。// 通过自定义比较器 (a, b) -> b - a 来实现最大堆，即堆顶元素为堆中最大的元素PriorityQueue<Integer> maxHeap = new PriorityQueue<>(10000, (a, b) -> b - a);// 遍历给定的数字数组for (int num : numbers) {if (maxHeap.size() < 10000) {// 如果堆的大小小于 10000，直接将当前数字加入堆中maxHeap.offer(num);} else if (num < maxHeap.peek()) {// 如果堆的大小已经达到 10000，且当前数字小于堆顶元素// 则移除堆顶元素（即当前堆中的最大元素），并将当前数字加入堆中maxHeap.poll();maxHeap.offer(num);}}// 创建一个大小为 10000 的数组，用于存储最终的前 10000 小的数字int[] top10000 = new int[10000];// 从数组的最后一个位置开始，将堆中的元素依次取出放入数组中for (int i = 9999; i >= 0; i--) {top10000[i] = maxHeap.poll();}return top10000;}public static void main(String[] args) {// 生成一个包含 100000 个随机数字的数组，数字范围在 0 到 999999 之间int[] numbers = new int[100000];for (int i = 0; i < 100000; i++) {numbers[i] = (int) (Math.random() * 1000000);}// 调用 getTop10000Smallest 方法，获取前 10000 小的数字int[] top10000 = getTop10000Smallest(numbers);// 对前 10000 小的数字进行排序，使用 Arrays 类的 sort 方法Arrays.sort(top10000);// 遍历排序后的数组，打印每个数字for (int num : top10000) {System.out.println(num);}}
}

代码解释

最大堆的创建：使用 PriorityQueue 来创建一个最大堆，堆的大小为 10000。通过自定义比较器 (a, b) -> b - a 来实现最大堆。
遍历数字数组：遍历 100000 个数字，若堆的大小小于 10000，直接将数字加入堆中；若当前数字小于堆顶元素，移除堆顶元素并加入当前数字。
将堆中的元素转换为数组：遍历堆，将堆中的元素依次取出放入数组中。
对前 10000 小的数字进行排序：使用 Arrays.sort 方法对数组进行排序。
打印排序后的结果：遍历排序后的数组，打印每个元素。

二叉树中最近公共祖先（LCA）

二叉树节点定义

class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val = x; }
}

最近公共祖先算法（递归解法）

public class LowestCommonAncestor {// 主函数：查找 p 和 q 的最近公共祖先public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {// 递归终止条件：当前节点为空，或找到 p 或 q（自己也是自己的祖先）if (root == null || root == p || root == q) {return root;}// 递归查找左子树和右子树TreeNode left = lowestCommonAncestor(root.left, p, q);TreeNode right = lowestCommonAncestor(root.right, p, q);// 情况 1：左子树和右子树都找到节点 → 说明当前根节点是 LCAif (left != null && right != null) {return root;}// 情况 2：左子树找到节点，右子树没找到 → 返回左子树的结果（可能是 p/q 或它们的祖先）else if (left != null) {return left;}// 情况 3：右子树找到节点，左子树没找到 → 返回右子树的结果else {return right;}}// 测试用例public static void main(String[] args) {// 构建示例二叉树TreeNode root = new TreeNode(3);root.left = new TreeNode(5);root.right = new TreeNode(1);root.left.left = new TreeNode(6);root.left.right = new TreeNode(2);root.right.left = new TreeNode(0);root.right.right = new TreeNode(8);root.left.right.left = new TreeNode(7);root.left.right.right = new TreeNode(4);LowestCommonAncestor solution = new LowestCommonAncestor();// 测试案例 1：p=5, q=1 → LCA 是 root(3)TreeNode p = root.left; // val=5TreeNode q = root.right; // val=1System.out.println("LCA of 5 and 1 is: " + solution.lowestCommonAncestor(root, p, q).val); // 输出 3// 测试案例 2：p=5, q=4 → LCA 是 5q = root.left.right.right; // val=4System.out.println("LCA of 5 and 4 is: " + solution.lowestCommonAncestor(root, p, q).val); // 输出 5// 测试案例 3：p=7, q=4 → LCA 是 2TreeNode p2 = root.left.right.left; // val=7q = root.left.right.right; // val=4System.out.println("LCA of 7 and 4 is: " + solution.lowestCommonAncestor(root, p2, q).val); // 输出 2}
}

算法原理（递归三要素）

终止条件：
- 当前节点为空（root == null）：说明没找到，返回 null
- 当前节点是 p 或 q：直接返回自己（自己是自己的祖先）
递归逻辑：
- 分别在左子树和右子树中查找 p 和 q 的祖先
- 若左子树和右子树都找到节点 → 说明当前节点是它们的公共祖先（因为左子树和右子树各有一个节点，当前节点是最近的公共祖先）
- 若只有左子树找到 → 结果在左子树中（可能是 p/q 或它们的祖先）
- 若只有右子树找到 → 结果在右子树中
合并结果：
通过递归的返回值，自底向上判断当前节点是否为 LCA，最终返回最近的那个祖先。

算法特点

时间复杂度：O (n)，每个节点最多被访问一次
空间复杂度：O (n)（递归栈空间，最坏情况下树退化为链表）
适用场景：二叉树（无论是否为二叉搜索树），且节点值唯一，p 和 q 一定存在于树中

关键思路

分治思想：将问题分解为左子树和右子树的子问题，通过子问题的解合并得到原问题的解
后序遍历：先处理左右子树，再处理当前节点，符合 “自底向上” 查找祖先的逻辑
唯一性假设：利用 “树中节点值唯一” 的特性，直接通过节点引用判断是否为 p 或 q

找View树的最近公共祖先

// 定义 View 类
class View {View[] childs;View parent;public View() {this.childs = null;this.parent = null;}
}public class ViewTreeLCA {// 查找两个 View 的最近公共祖先public static View findLowestCommonAncestor(View view1, View view2) {// 存储 view1 到根节点的路径java.util.HashSet<View> path = new java.util.HashSet<>();// 从 view1 开始，将其到根节点的路径上的所有 View 加入到 path 集合中View current = view1;while (current != null) {path.add(current);current = current.parent;}// 从 view2 开始，沿着其父节点向上遍历current = view2;while (current != null) {// 如果当前 View 已经在 path 集合中，说明找到了最近公共祖先if (path.contains(current)) {return current;}current = current.parent;}// 如果没有找到公共祖先，返回 nullreturn null;}public static void main(String[] args) {// 构建一个简单的 View 树View root = new View();View child1 = new View();View child2 = new View();View grandChild1 = new View();View grandChild2 = new View();root.childs = new View[]{child1, child2};child1.parent = root;child2.parent = root;child1.childs = new View[]{grandChild1};grandChild1.parent = child1;child2.childs = new View[]{grandChild2};grandChild2.parent = child2;// 查找 grandChild1 和 grandChild2 的最近公共祖先View lca = findLowestCommonAncestor(grandChild1, grandChild2);if (lca != null) {System.out.println("最近公共祖先是存在的。");} else {System.out.println("未找到最近公共祖先。");}}
}

代码思路：

存储路径：首先，从 view1 开始，沿着其父节点向上遍历，将经过的所有 View 存储在一个 HashSet 中，这个集合记录了 view1 到根节点的路径。
查找公共祖先：接着，从 view2 开始，同样沿着其父节点向上遍历。对于每个经过的 View，检查它是否已经在之前存储的路径集合中。如果存在，说明找到了最近公共祖先，返回该 View。
未找到情况：如果遍历完 view2 到根节点的路径都没有找到公共祖先，返回 null。