hoyyoung的博客

1. 实现思路1.1 算法方法结构1. void quickSort(int[] array, int left, int right) 2. int[] partition(int[] array, int left, int right)3. void swap(int[] array, int index1, int index2)1.2 图解思路2. 代码实现 // 快速排序 public static void quickSort(int[] array, int

1. 实现思路1.1【递归法】： 递归"裂变"计算f值，计算次数较多基本情况：k < 2, f(k) = k递归收缩：k > 2, f(k) = f(k -1) + f(k - 2)1.2【遍历法】：逐个储存+计算下一个f值k < 2, f(k) = kloop 逐个计算，算到k停止：k > 2, f(k) = f(k -1) + f(k - 2)返回最后一个值1.3 【数组法】：将计算过的f值储存在array里k < 2, f(k) = k设置用

1. 排序思路循环：由mid点不断分割查找当left > right 且 搜索值超出查找数组的范围时停止当left == right 且 left值 == right值时，无法作mid被除数，停止当找到时，返回此时的下标mid分割值下标mid = left + (right - left) * [(searchValue - array[left]) / (array[right] - array[left])]2. 代码实现 /** * 插值查找（优化二分查找

1. 查找思路1.1 二分查找（递归实现，只返回第一个找到位置的下标）基本条件：left > right，说明没找到，返回-1得到中间点下标 mid比较，分割，查找3.1 若 待寻找的数 < 中间点数值：继续在中间点左边数组中查找3.2 若 待寻找的数 > 中间点数值：继续在中间点右边数组中查找3.3 若 待寻找的数 = 中间点数值：找到，返回当前中间点下标1.2 二分查找（递归实现，返回全部找到位置的下标）新建list，存放要返回的全部下标值基本条件：left

1. 排序思路获得最大数的位数新建：桶数组 + 桶数据记录数组循环，入桶+出桶3.1 入桶：每个数据分别入相应的桶3.2 出桶：遍历所有的桶，按桶的顺序依次取出数据，并放入原数组2. 代码实现 /** * 基数排序 * 思路： * 1. 获得最大数的位数 * 2. 新建：桶数组 + 桶数据记录数组 * 3. 循环，入桶+出桶 * 3.1 入桶：每个数据分别入相应的桶 *

1. 排序思路分解数组，每次都一分为二[8, 4, 2, 6, 7, 1, 9, 3, 20, 18, 11, 15][8, 4, 2, 6, 7, 1] [ 9, 3, 20, 18, 11, 15][8, 4, 2] [6, 7, 1] [9, 3, 20] [18, 11, 15][8, 4] [2] [6, 7] [1] [9, 3] [20] [18, 11] [15][8] [4] [2] [6] [7] [1] [9] [3] [20] [18] [11] [15]两两合并(有

1. 算法思路快速排序是对 冒泡排序 的改进：找到中轴点pivot（中点）pivot左右互相交换，使得：左边 < pivot，右边 > pivot对左边和右边数组分别重复上述步骤2. 代码实现 /** * 快速排序 * 思路： * step1: * [ 8, 4, 2, <6>, 7, 1, 9, 3 ] * left->

1. 排序思路不断将原数组分组，每组进行"简单插入排序"分组方式为：第一次分 length/2 组，第二次分 length/2/2 组，第三次分 length/2/2/2 组，…，以此类推，最后一次分为 1 组结束分组和分别的插入排序，整个数组的排序即完成注意：插入方法有"交换法"（效率低）和"移位法"（高效）两种2. 代码实现 /** * 希尔排序(缩小增量排序） * 思路： * - 不断将原数组分组，每组进行

1. 排序思路将数组分为"有序表"和"无序表""有序表"初始为第一个数，"无序表"为剩下数组将"无序表"的首位与"有序表"逐个比较，寻找插入点寻找时，从"无序表"首位的前一位开始比较，通过交换依次往前移动若 "无序表"首位 < "无序表"首位的前一位：未找到插入点，交换两数，继续寻找否则: 找到，停止小循环继续下一轮当"无序表"为1时，排序完成2. 复杂度分析T(n) = n + 1 + n * (n - 1) + 1 = n2 = O(n2)3. 代码实现

1. 排序思路共进行 length - 1 次 “大循环”每轮循环，找到该轮 “最小值”，和 “未排序数组的首位” 交换2. 复杂度分析：T(n) = n + 1 + n * (n - 1) + 1 = n2 = O(n2)3. 代码实现 /** * 简单选择排序 * 思路： * - 共进行 length - 1 次 “大循环” * - 每轮循环，找到该轮 "最小值"，和 "未排序数组的首位" 交换 *

1. 排序思路共进行 length - 1 次 “大循环”每趟循环，排序的次数逐次减少每躺排序，两两比较大小，每次比较都把大的后移-（优化）若某躺大循环中，没有发生“交换”，则结束整个排序2. 代码实现 /** * 冒泡排序 * - 共进行 length - 1 次 “大循环” * - 每趟循环，排序的次数逐次减少 * - 每躺排序，两两比较大小，每次比较都把大的后移 * -（优化）若某躺大循环中

1. 递归思路基本情况：放置到第8个皇后（即找到一个解法）向基本情况靠近：若当前皇后的放置位置不冲突，则放置下一个皇后到下一行调用自身：将当前皇后数加1后作为参数，继续放置2. 代码实现/** * 八皇后问题 - 回溯算法（递归） */public class EightQueenProblem { /** * 一位数组表示棋盘 * index - 行 * data - 列 */ private static int[] ches

1. 代码实现/** * 使用回溯算法（递归）解决"迷宫问题" */public class Maze { int[][] mazeMap = new int[11][22]; final int[] startPosition = new int[]{8, 15}; final int[] endPosition = new int[]{1, 21}; public Maze() { this.generateMazeMap();

public class PolandNotation { /** * @author hoy * 中缀表达式 -> 后缀表达式list<String> * 思路： * 1. 创建一个堆栈，operatorStack<string> 用于保留运算符； 创建一个list，postfixList<string> 用于保留中间结果。 * 2. 原始中缀表达式 -> 中缀表达式list&l

1. 中缀计算器public class InfixCalculator { /** * @author - hoy * 计算器：计算所给出数学表达式字符串的结果，返回结果值（只计算个位数的数字输入，无括号） * @param expression - 表达式字符串 * @return - 返回计算结果 */ public static int infixCalculator(String expression) { //

1. 问题描述设编号为 1,2,3,…,n 的 n 个人围坐在一起，让编号为 k (1 <= k <= n) 的人从 1 开始报数，数到第 m 个的这个人出列，然后从此人的下一人再从 1 开始报数，数到 m 的出列，以此类推，直到所有人都出列。打印出整个过程的出队编号序列。2. 解决思路利用 单向环形链表步骤：初始化环形链表 和 出队数组校验：是否都是正数；startNodeData是否在链表长度范围内设置preNode，作为firstNode的上一个节点将first移动到