From aefb5bd67fa58103e2ca8d0a4f10aad7bd0bfbcc Mon Sep 17 00:00:00 2001
From: msb_110050 <msb_110050@mashibing.com>
Date: Fri, 18 Nov 2022 18:02:57 +0800
Subject: [PATCH] =?UTF-8?q?=E4=B8=8A=E4=BC=A0=E6=96=87=E4=BB=B6=E8=87=B3?=
 =?UTF-8?q?=20'algorithm'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 algorithm/位运算.md | 34 +++++++++++++++
 algorithm/算法.md    | 94 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 128 insertions(+)
 create mode 100644 algorithm/位运算.md
 create mode 100644 algorithm/算法.md

diff --git a/algorithm/位运算.md b/algorithm/位运算.md
new file mode 100644
index 0000000..6220d80
--- /dev/null
+++ b/algorithm/位运算.md
@@ -0,0 +1,34 @@
+一个数的相反数为取反加1.
+取反的结果和原来的数相加结果为2^32^-1,再加1则进位为0。
+
+2^32^-1二进制为
+
+```shell
+11111111 11111111 11111111 11111111
+```
+
+```shell
+# 例如 int a = 1024;二进制为
+00000000 00000000 00001000 00000000
+# 取反后
+11111111 11111111 11110111 11111111
+# 相加为
+11111111 11111111 11111111 11111111 
+a+~a+1=0;则-a=~a+1;
+```
+
+```Java
+# 打印int类型二进制字符串方法
+private static void printCompleteBinaryStr(int num){
+    for (int i = 31; i >= 0; i--) {
+        System.out.print((num & (1 << i)) == 0 ? "0" : "1");
+        if (i < 31 && (i + 1) % 8 == 0) {
+            System.out.print(" ");
+        }
+    }
+    System.out.println();
+}
+```
+
+Integer.MIN_VALUE取反加一后仍然为Integer.MIN_VALUE，这不是bug。
+Integer.MAX_VALUE加1后溢出为Integer.MIN_VALUE，Integer.MIN_VALUE减一则溢出为Integer.MAX_VALUE。
diff --git a/algorithm/算法.md b/algorithm/算法.md
new file mode 100644
index 0000000..e7bf584
--- /dev/null
+++ b/algorithm/算法.md
@@ -0,0 +1,94 @@
+# 算法的5个特点
+
+1.有穷性
+2.确定性(确定的执行流程或者确定的尝试流程)
+3.可行性
+4.输入
+5.输出
+
+# 选择排序
+
+双层循环，内层循环完成后获取最小值，内层循环每次将最小值放到i位置。
+0-i之间认为是有序，i-n之间是原始数据，从i-n之间选择最小的元素放到index为i的地方。
+
+注意数组的交换，小于号避免相同元素交换位置。
+
+```Java
+private static void selectionSort(int[] arr) {
+    if (arr == null || arr.length < 2) {
+        return;
+    }
+
+    int length = arr.length;
+    int tmp;
+    for (int i = 0; i < length; i++) {
+        int index = i;
+        for (int j = i; j < length; j++) {
+            // 小于号避免位置交换
+            index = arr[j] < arr[index] ? j : index;
+        }
+        if (index == i) {
+            continue;
+        }
+        tmp = arr[i];
+        arr[i] = arr[index];
+        arr[index] = tmp;
+    }
+}
+```
+
+# 冒泡排序
+
+双层循环，内层循环两两交换，内层循环完成后将最大值冒泡到最右边。
+外层循环index从大到小，内层循环index从小到大。
+
+```Java
+private static void bubbleSort(int[] arr){
+    int length = arr.length;
+    if (arr == null || length < 2) {
+        return;
+    }
+
+    int tmp;
+    for (int i = length - 1; i >= 0; i--) {
+        for (int j = 0; j < i; j++) {
+            if (arr[j + 1] < arr[j]) {
+                tmp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = tmp;
+            }
+        }
+    }
+}
+```
+
+# 插入排序
+
+每次获取原始数据最前面的那个元素交换到左侧已经有序的数组。
+双层循环，外层循环每次递增并获取i，内层循环使用i挨个和0-1的数据比较并交换。如果i比i-1大或者内层循环到了最左侧则终止循环。
+
+```Java
+private static void insertSort(int[] arr){
+    int length = arr.length;
+    if (arr == null || length < 2) {
+        return;
+    }
+    int tmp;
+    for (int i = 0; i < length; i++) {
+        for (int j = i; j > 0; j--) {
+            if (arr[j - 1] > arr[j]) {
+                tmp = arr[j - 1];
+                arr[j - 1] = arr[j];
+                arr[j] = tmp;
+            } else {
+                break;
+            }
+
+        }
+    }
+}
+```
+
+## 排序算法的稳定性问题？？？
+
+在涉及到元素交换的时候，判断不使用等于，则相同的元素不会被交换。