From 873e396bf56c84949f23fde895a6b52cfed2c8a9 Mon Sep 17 00:00:00 2001 From: kn5886348135 <56352848+kn5886348135@users.noreply.github.com> Date: Sat, 19 Nov 2022 17:57:32 +0800 Subject: [PATCH] =?UTF-8?q?=E5=89=8D=E7=BC=80=E5=92=8C=E3=80=81=E9=9A=8F?= =?UTF-8?q?=E6=9C=BA=E8=8E=B7=E5=8F=96-b=E3=80=81=E4=BA=8C=E5=88=86?= =?UTF-8?q?=E6=9F=A5=E6=89=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- algorithm/数据结构.md | 118 +++++++++++++++++++++++++ algorithm/时间复杂度.md | 77 ++++++++++++++++ algorithm/算法.md | 10 +-- framework-source-code/spring/spring.md | 32 +++++++ 4 files changed, 232 insertions(+), 5 deletions(-) create mode 100644 algorithm/数据结构.md create mode 100644 algorithm/时间复杂度.md create mode 100644 framework-source-code/spring/spring.md diff --git a/algorithm/数据结构.md b/algorithm/数据结构.md new file mode 100644 index 0000000..9598e2b --- /dev/null +++ b/algorithm/数据结构.md @@ -0,0 +1,118 @@ +## 数据结构 + +* 数据结构是存储、组织数据的方式 +* 精心选择的数据结构可以带来更高的运行或者存储效率 +* 数据结构是很多算法得以进行的载体 + +### 最基本的数据结构 + +* 数组 按照下标寻址的时间复杂度为O(1)，不便于增删数据 +* 链表 便于增删数据，不便于寻址 + +### 前缀和数组 + +可以考虑使用二维数组保存前缀和，避免每次做减法。 + +```Java +private static int preSum(int[] arr, int left,int right) { + int length = arr.length; + int[] preSum = new int[length]; + for (int i = 0; i < length; i++) { + if (i == 0) { + preSum[i] = arr[i]; + } else { + preSum[i] = preSum[i - 1] + arr[i]; + } + } + return left == 0 ? preSum[right] : preSum[right] - preSum[left]; +} +``` + +从1-5随机到1-7随机 +从a-b随机到c-d随机 +01不等概率随机到01等概率随机 + +```Java + private static int f1(){ + return (int) (Math.random() * 5) + 1; + } + + private static int f2(){ + int ans = 0; + do { + ans = f1(); + } while (ans == 3); + return ans < 3 ? 0 : 1; + } + + // 000 - 111 等概率 + private static int f3(){ + return f2() << 2 + f2() << 1 + f2(); + } +``` + +固定概率方法等概率返回0或者1 + +```Java +// 固定概率返回0或者1 +private static int x(){ + return Math.random() < 0.84 ? 0 : 1; +} + +// 等概率返回0或者1 +private static int y() { + int ans = 0; + do { + ans = x(); + } while (ans == x()); + return ans; +} +``` + +生成随机数组，判断排序结果 + +```Java +public static void main(String[] args) { + int maxLen = 50; + int maxValue = 3000; + int times = 10000; + for (int i = 0; i < times; i++) { + int[] arr = randomArr(maxLen, maxValue); + int[] tmp = copyArr(arr); + // selectionSort(arr); + // bubbleSort(arr); + insertSort(arr); + boolean result = validateArr(arr); + if (!result) { + for (int j = 0; j < arr.length; j++) { + System.out.print(tmp[j] + " "); + } + System.out.println(); + System.out.println("排序结果错误"); + break; + } + } + +} + +private static int[] copyArr(int[] arr){ + int[] ans = new int[arr.length]; + for (int i = 0; i < arr.length; i++) { + ans[i] = arr[i]; + } + return ans; +} + +private static boolean validateArr(int[] arr) { + if (arr.length < 2) { + return true; + } + int max = arr[0]; + for (int i = 1; i < arr.length; i++) { + if (max > arr[i]) { + return false; + } + } + return true; +} +``` diff --git a/algorithm/时间复杂度.md b/algorithm/时间复杂度.md new file mode 100644 index 0000000..2624999 --- /dev/null +++ b/algorithm/时间复杂度.md @@ -0,0 +1,77 @@ +### 二分法问题 + +* 有序数组中找到num +* 有序数组中找到>=num最左的位置 +* 有序数组中找到<=num最右的位置 +* 局部最小值问题 + +使用while循环，根据target在middle的位置，移动left或者right。 + +```Java +private static int binarySearch(int[] arr, int target) { + if (arr == null || arr.length == 0) { + return -1; + } + int length = arr.length; + int left = 0; + int right = length-1; + int index = -1; + int middle; + while (left <= right) { + middle = (left + right) >> 1; + if (arr[middle] == target) { + index = middle; + return index; + } else if (arr[middle] < target) { + left = middle + 1; + } else { + right = middle - 1; + } + } + return index; +} + +// 大于等于target最左的位置 +private static int binarySearchLeft(int[] arr, int target) { + if (arr == null || arr.length == 0) { + return -1; + } + int length = arr.length; + int left = 0; + int right = length-1; + int index = -1; + int middle; + while (left <= right) { + middle = (left + right) >> 1; + if (arr[middle] >= target) { + index = middle; + right = middle - 1; + } else { + left = middle + 1; + } + } + return index; +} + +// 小于等于target最右的位置 +private static int binarySearchRight(int[] arr, int target) { + if (arr == null || arr.length == 0) { + return -1; + } + int length = arr.length; + int left = 0; + int right = length-1; + int index = -1; + int middle; + while (left <= right) { + middle = (left + right) >> 1; + if (arr[middle] <= target) { + index = middle; + left = middle + 1; + } else { + right = middle - 1; + } + } + return index; +} +``` diff --git a/algorithm/算法.md b/algorithm/算法.md index e7bf584..19be663 100644 --- a/algorithm/算法.md +++ b/algorithm/算法.md @@ -11,7 +11,7 @@ 双层循环，内层循环完成后获取最小值，内层循环每次将最小值放到i位置。 0-i之间认为是有序，i-n之间是原始数据，从i-n之间选择最小的元素放到index为i的地方。 -注意数组的交换，小于号避免相同元素交换位置。 +不稳定的排序 ```Java private static void selectionSort(int[] arr) { @@ -42,6 +42,8 @@ private static void selectionSort(int[] arr) { 双层循环，内层循环两两交换，内层循环完成后将最大值冒泡到最右边。 外层循环index从大到小，内层循环index从小到大。 +稳定排序 + ```Java private static void bubbleSort(int[] arr){ int length = arr.length; @@ -67,6 +69,8 @@ private static void bubbleSort(int[] arr){ 每次获取原始数据最前面的那个元素交换到左侧已经有序的数组。 双层循环，外层循环每次递增并获取i，内层循环使用i挨个和0-1的数据比较并交换。如果i比i-1大或者内层循环到了最左侧则终止循环。 +稳定排序 + ```Java private static void insertSort(int[] arr){ int length = arr.length; @@ -88,7 +92,3 @@ private static void insertSort(int[] arr){ } } ``` - -## 排序算法的稳定性问题？？？ - -在涉及到元素交换的时候，判断不使用等于，则相同的元素不会被交换。 diff --git a/framework-source-code/spring/spring.md b/framework-source-code/spring/spring.md new file mode 100644 index 0000000..f58ae6f --- /dev/null +++ b/framework-source-code/spring/spring.md @@ -0,0 +1,32 @@ +### 框架源码的前置知识 + +* 设计模式 +* 数据结构与算法 +* 反射 +* 多线程 +* JVM + +IOC控制反转 +DI依赖注入 + +```xml + + + + +``` + +```Java +ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml") +XXX xxbean = context.getBean(XXX.class); +xxbean.method(); +``` + +#### SSM框架项目中spring处理bean的主要流程 + +* 加载xml文件 +* 解析xml文件 +* 封装BeanDefinition +* 实例化 +* 放到容器中 +* 从容器中获取