前缀和、随机获取-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;
+}
+```

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;
+}
+```

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){
     }
 }
 ```
-
-## 排序算法的稳定性问题？？？
-
-在涉及到元素交换的时候，判断不使用等于，则相同的元素不会被交换。

framework-source-code/spring/spring.md

@@ -0,0 +1,32 @@
+### 框架源码的前置知识
+
+* 设计模式
+* 数据结构与算法
+* 反射
+* 多线程
+* JVM
+
+IOC控制反转
+DI依赖注入
+
+```xml
+    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" abstract="xxx" autowire="byName" autowire-candidate="default" depends-on="environment" init-method="afterPropertiesSet">
+        <!-- 注入数据库连接池 -->
+        <property name="dataSource" ref="dataSource"/>
+    </bean>
+```
+
+```Java
+ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml")
+XXX xxbean = context.getBean(XXX.class);
+xxbean.method();
+```
+
+#### SSM框架项目中spring处理bean的主要流程
+
+* 加载xml文件
+* 解析xml文件
+* 封装BeanDefinition
+* 实例化
+* 放到容器中
+* 从容器中获取