左程云算法新手班 day1

README.md

@@ -3,7 +3,7 @@
 [数据结构](src/main/java/data_struct/README.md)
 
 # 操作系统
-[jvm](src/main/java/org/tianbin/jvm)
+[jvm](src/main/java/cc/tianbin/jvm)
 
 # 网络编程
-[org.tianbin.netty](src/main/java/org/tianbin/netty/README.md)
+[org.tianbin.netty](src/main/java/cc/tianbin/netty/README.md)

pom.xml

@@ -77,6 +77,11 @@
             <artifactId>junit</artifactId>
             <version>4.13.2</version>
         </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-simple</artifactId>
+            <version>1.7.36</version>
+        </dependency>
 
     </dependencies>
 

src/main/java/algorithm_practice/a_Sorting/a_Selection.java

@@ -15,11 +15,10 @@
  */
 public class a_Selection {
     public static void main(String[] args) {
-        int[] a = new int[10];
-        a = SysRandom.random(a);
+        int[] a = SysRandom.randomArr();
         SysOut.printArray(a);
 
-        a = Selection_Sort(a);
+        Selection_Sort(a);
         SysOut.printArray(a);
     }
 

src/main/java/algorithm_practice/a_Sorting/b_Insertion.java

@@ -9,8 +9,7 @@
  */
 public class b_Insertion {
     public static void main(String[] args) {
-        int[] a = new int[10];
-        a = SysRandom.random(a);
+        int[] a = SysRandom.randomArr();
         SysOut.printArray(a);
 
         a = Insertion_Sort(a);

src/main/java/algorithm_practice/a_Sorting/d_Merge.java

@@ -10,8 +10,7 @@
 public class d_Merge {
 
     public static void main(String[] args) {
-        int[] a = new int[7];
-        a = SysRandom.random(a);
+        int[] a = SysRandom.randomArr();
         SysOut.printArray(a);
 
         divide(a, 0, a.length - 1);

src/main/java/algorithm_practice/algorithmzuo/README.md

@@ -0,0 +1,4 @@
+# 跟着左神写算法
+<https://github.com/algorithmzuo>
+
+笔记：<https://www.yuque.com/nibnait/algorithm>

src/main/java/algorithm_practice/algorithmzuo/a_primary/README.md

@@ -0,0 +1,2 @@
+# 新手班
+<https://github.com/algorithmzuo/algorithm-primary>

src/main/java/algorithm_practice/algorithmzuo/a_primary/class01/Code01_PrintBinary.java

@@ -0,0 +1,60 @@
+package algorithm_practice.algorithmzuo.a_primary.class01;
+
+import common.util.SystemUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Test;
+
+import java.math.BigDecimal;
+
+/**
+ * Created by nibnait on 2022/06/20
+ */
+@Slf4j
+public class Code01_PrintBinary {
+
+    @Test
+    public void testCase() {
+
+        int num = 4;
+        print(num);
+        print(0);
+
+        print(Integer.MAX_VALUE);
+        print(Integer.MIN_VALUE);
+        print(Integer.MIN_VALUE + 1);
+        print(Integer.MIN_VALUE + 2);
+        print(Integer.MIN_VALUE + 3);
+        print(Integer.MIN_VALUE + 4);
+        print(Integer.MIN_VALUE + 5);
+
+        print(-1);
+
+        print(BigDecimal.valueOf(Math.pow(2, 32)).intValue());
+        print(BigDecimal.valueOf(Math.pow(2, 31)).intValue());
+        print(BigDecimal.valueOf(Math.pow(2, 30)).intValue());
+
+        SystemUtil.printCuttingLine();
+
+        // 带符号右移 和 不带符号右移
+        num = 1024;
+        print(num >> 1);
+        print(num >>> 1);
+        SystemUtil.printCuttingLine();
+
+        // 为什么负数的二进制要取反加1？
+        // 为了加法 正+正 与 正+负。。走一套逻辑。
+        num = 5;
+        print(num);
+        print(-num);
+        print(~num + 1);
+    }
+
+    private void print(int num) {
+        System.out.print(num + "\t");
+        for (int i = 31; i >= 0; i--) {
+            System.out.print( (num & (1 << i)) == 0 ? "0" : "1");
+        }
+        System.out.println();
+    }
+
+}

src/main/java/algorithm_practice/algorithmzuo/a_primary/class01/Code02_SumOfFactorial.java

@@ -0,0 +1,37 @@
+package algorithm_practice.algorithmzuo.a_primary.class01;
+
+public class Code02_SumOfFactorial {
+
+	public static long f1(int N) {
+		long ans = 0;
+		for (int i = 1; i <= N; i++) {
+			ans += factorial(i);
+		}
+		return ans;
+	}
+
+	public static long factorial(int N) {
+		long ans = 1;
+		for (int i = 1; i <= N; i++) {
+			ans *= i;
+		}
+		return ans;
+	}
+
+	public static long f2(int N) {
+		long ans = 0;
+		long cur = 1;
+		for (int i = 1; i <= N; i++) {
+			cur = cur * i;
+			ans += cur;
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		int N = 10;
+		System.out.println(f1(N));
+		System.out.println(f2(N));
+	}
+
+}

src/main/java/algorithm_practice/algorithmzuo/a_primary/class01/Code03_SelectionSort.java

@@ -0,0 +1,46 @@
+package algorithm_practice.algorithmzuo.a_primary.class01;
+
+import common.util.CompareUtils;
+import common.util.SysOut;
+import common.util.SysRandom;
+import common.util.SystemUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static common.util.SwapUtil.swap;
+
+/**
+ * Created by nibnait on 2022/06/21
+ */
+public class Code03_SelectionSort {
+
+    @Test
+    public void testCase() {
+        for (int i = 0; i < 10; i++) {
+            int arr[] = SysRandom.randomArr();
+            SysOut.printArray(arr);
+            selectSort(arr);
+            SysOut.printArray(arr);
+            Assert.assertTrue(CompareUtils.isSortAsc(arr));
+
+            SystemUtil.printLiteCuttingLine();
+        }
+    }
+
+    private void selectSort(int[] arr) {
+        if (arr == null || arr.length < 2) {
+            return;
+        }
+
+        int length = arr.length;
+        for (int i = 0; i < length - 1; i++) {
+            int minValueIndex = i;
+            for (int j = i+1; j < length; j++) {
+                minValueIndex = arr[j] < arr[minValueIndex] ? j : minValueIndex;
+            }
+            swap(arr, i, minValueIndex);
+        }
+
+    }
+
+}

src/main/java/algorithm_practice/algorithmzuo/a_primary/class01/Code04_BubbleSort.java

@@ -0,0 +1,46 @@
+package algorithm_practice.algorithmzuo.a_primary.class01;
+
+import common.util.CompareUtils;
+import common.util.SysOut;
+import common.util.SysRandom;
+import common.util.SystemUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static common.util.SwapUtil.swap;
+
+/**
+ * Created by nibnait on 2022/06/21
+ */
+public class Code04_BubbleSort {
+
+    @Test
+    public void testCase() {
+        for (int i = 0; i < 10; i++) {
+            int arr[] = SysRandom.randomArr();
+            SysOut.printArray(arr);
+            bubbleSort(arr);
+            SysOut.printArray(arr);
+            Assert.assertTrue(CompareUtils.isSortAsc(arr));
+
+            SystemUtil.printLiteCuttingLine();
+        }
+    }
+
+    private void bubbleSort(int[] arr) {
+        if (arr == null || arr.length < 2) {
+            return;
+        }
+
+        int length = arr.length;
+        for (int end = length - 1; end > 0; end--) {
+            for (int i = 0; i < end; i++) {
+                if (arr[i] > arr[i + 1]) {
+                    swap(arr, i, i + 1);
+                }
+            }
+        }
+
+    }
+
+}

src/main/java/algorithm_practice/algorithmzuo/a_primary/class01/Code05_InsertionSort.java

@@ -0,0 +1,45 @@
+package algorithm_practice.algorithmzuo.a_primary.class01;
+
+import common.util.CompareUtils;
+import common.util.SysOut;
+import common.util.SysRandom;
+import common.util.SystemUtil;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static common.util.SwapUtil.swap;
+
+/**
+ * Created by nibnait on 2022/06/21
+ */
+public class Code05_InsertionSort {
+
+    @Test
+    public void testCase() {
+        for (int i = 0; i < 10; i++) {
+            int arr[] = SysRandom.randomArr();
+            SysOut.printArray(arr);
+            insertSort(arr);
+            SysOut.printArray(arr);
+            Assert.assertTrue(CompareUtils.isSortAsc(arr));
+
+            SystemUtil.printLiteCuttingLine();
+        }
+    }
+
+    private void insertSort(int[] arr) {
+        if (arr == null || arr.length < 2) {
+            return;
+        }
+
+        int length = arr.length;
+        for (int end = 1; end < length; end++) {
+            int newNumIndex = end;
+            while (newNumIndex - 1 >= 0 && arr[newNumIndex - 1] > arr[newNumIndex]) {
+                swap(arr, newNumIndex - 1, newNumIndex);
+                newNumIndex--;
+            }
+        }
+    }
+
+}

src/main/java/algorithm_practice/algorithmzuo/a_primary/class01/README.md

@@ -0,0 +1,63 @@
+## 内容：
+- 讲解二进制、位运算
+- 介绍什么是算法
+- 讲解冒泡、选择、插入排序
+## 题目：
+### 实现打印一个整数的二进制
+```java
+/**
+ * 无符号整数
+ */
+public void print(int num) {
+    for(int i=31; i>=0; i--) {
+        System.out.print( num & (1<<i) == 0 ? "0" : "1");   
+    }
+    System.out.println();
+}
+```
+从右往左数，第31位二进制数，num & 1000...000 == 0 ？ "0"  : "1"
+从右往左数，第30位二进制数，num & 0100...000 == 0 ？ "0"  : "1"
+...
+从右往左数，第0位二进制数，num & 0000...001 == 0 ？ "0"  : "1"
+**负数为什么要取反+1？**
+为了计算 正数+负数时，与正数+正数，底层位运算用一套逻辑。所以负数的二进制要取反+1
+### 给定一个参数N，返回1!+2!+3!+4!+…+N!的结果
+f1：暴力计算，每轮都乘n次
+f2：保存上一次的接口，每轮只乘1次
+### 实现选择排序
+0 ~ n-1
+1 ~ n-1
+每轮选个最小的 放到前面
+```java
+for (int i = 0; i < length - 1; i++) {
+    int minValueIndex = i;
+    for (int j = i+1; j < length; j++) {
+        minValueIndex = arr[j] < arr[minValueIndex] ? j : minValueIndex;
+    }
+    swap(arr, i, minValueIndex);
+}
+```
+### 实现冒泡排序
+0 ~ n-1
+0 ~ n-2
+每轮冒泡 冒一个最大的放到后面
+```java
+for (int end = length - 1; end > 0; end--) {
+    for (int i = 0; i < end; i++) {
+        if (arr[i] > arr[i + 1]) {
+            swap(arr, i, i + 1);
+        }
+    }
+}
+```
+### 实现插入排序
+打扑克 抓牌、码牌
+```java
+for (int end = 1; end < length; end++) {
+    int newNumIndex = end;
+    while (newNumIndex - 1 >= 0 && arr[newNumIndex - 1] > arr[newNumIndex]) {
+        swap(arr, newNumIndex - 1, newNumIndex);
+        newNumIndex--;
+    }
+}
+```

src/main/java/algorithm_practice/algorithmzuo/a_primary/class02/README.md

@@ -0,0 +1,15 @@
+## 内容：
+- 什么是数据结构、组成各种数据结构最基本的元件
+- 前缀和数组
+- 随机函数
+- 对数器的使用
+## 题目：
+### 实现前缀和数组
+
+### 如何用1~5的随机函数加工出1~7的随机函数
+
+### 如何用a~b的随机函数加工出c~d的随机函数
+
+### 展示对数器的使用
+
+### 如何把不等概率随机函数变成等概率随机函数