feat: add basic knowledge

Author: yanglbme

basic/README.md

@@ -0,0 +1,6 @@
+# 算法
+
+## 常见的排序算法
+
+- 冒泡排序
+- 插入排序

basic/sort/BubbleSort.java

@@ -0,0 +1,21 @@
+public class BubbleSort {
+    private static void swap(int[] nums, int i, int j) {
+        int t = nums[i];
+        nums[i] = nums[j];
+        nums[j] = t;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {1, 2, 7, 9, 5, 8};
+        boolean hasChange = true;
+        for (int i = 0; i < nums.length - 1 && hasChange; ++i) {
+            hasChange = false;
+            for (int j = 0; j < nums.length - 1 - i; ++j) {
+                if (nums[j] > nums[j + 1]) {
+                    swap(nums, j, j + 1);
+                    hasChange = true;
+                }
+            }
+        }
+    }
+}

basic/sort/InsertionSort.java

@@ -0,0 +1,14 @@
+public class InsertionSort {
+    
+    public static void main(String[] args) {
+        int[] nums = { 1, 2, 7, 9, 5, 8 };
+
+        for (int i = 1, j, current; i < nums.length; ++i) {
+            current = nums[i];
+            for (j = i - 1; j >=0 && nums[j] > current; --j) {
+                nums[j + 1] = nums[j];
+            }
+            nums[j + 1] = current;
+        }
+    }
+}

basic/sort/README.md

@@ -0,0 +1,64 @@
+# 常见的排序算法
+
+## 冒泡排序
+
+定义一个布尔变量 `hasChange`，用来标记每轮是否进行了交换。在每轮遍历开始时，将 `hasChange` 设置为 false。
+
+### 代码示例
+
+```java
+for (int i = 0; i < nums.length - 1; ++i) {
+    for (int j = 0; j < nums.length - 1 - i; ++j) {
+        if (nums[j] > nums[j + 1]) {
+            swap(nums, j, j + 1);
+        }
+    }
+}
+```
+
+### 算法分析
+
+空间复杂度 O(1)、时间复杂度 O(n^2)。
+
+分情况讨论：
+
+1. 给定的数组按照顺序已经排好：只需要进行 `n-1` 次比较，两两交换次数为 0，时间复杂度为 O(n)，这是最好的情况。
+2. 给定的数组按照逆序排列：需要进行 `n*(n-1)/2` 次比较，时间复杂度为 O(n^2)，这是最坏的情况。
+3. 给定的数组杂乱无章。在这种情况下，平均时间复杂度 O(n^2)。
+
+因此，时间复杂度是 O(n^2)，这是一种稳定的排序算法。
+
+> 稳定是指，两个相等的数，在排序过后，相对位置保持不变。
+
+## 插入排序
+
+与冒泡排序对比：
+
+- 在冒泡排序中，经过每一轮的排序处理后，数组后端的数是排好序的。
+- 在插入排序中，经过每一轮的排序处理后，数组前端的数是拍好序的。
+
+插入排序算法的基本思想是：不断将尚未排好序的数插入到已经排好序的部分。
+
+### 代码示例
+
+```java
+for (int i = 1, j, current; i < nums.length; ++i) {
+    current = nums[i];
+    for (j = i - 1; j >=0 && nums[j] > current; --j) {
+        nums[j + 1] = nums[j];
+    }
+    nums[j + 1] = current;
+}
+```
+
+### 算法分析
+
+空间复杂度 O(1)，时间复杂度 O(n^2)。
+
+分情况讨论：
+
+1. 给定的数组按照顺序排好序：只需要进行 n-1 次比较，两两交换次数为 0，时间复杂度为 O(n)，这是最好的情况。
+2. 给定的数组按照逆序排列：需要进行 `n*(n-1)/2` 次比较，时间复杂度为 O(n^2)，这是最坏的情况。
+3. 给定的数组杂乱无章：在这种情况下，平均时间复杂度是 O(n^2)。
+
+因此，时间复杂度是 O(n^2)，这也是一种稳定的排序算法。

solution/0500-0599/0502.IPO/Solution.java

@@ -0,0 +1,38 @@
+class Solution {
+    /**
+     * 贪心算法
+     */
+    public int findMaximizedCapital(int k, int W, int[] Profits, int[] Capital) {
+        // 首先检查是否存在所有项目都可投资且初始资本 W >= max(Capital) 的情况。如果是，返回利润中前 k 个最大元素的和。
+        boolean speedUp = true;
+        for (int c : Capital) if (W < c) speedUp = false;
+        if (speedUp) {
+            PriorityQueue<Integer> heap = new PriorityQueue<>();
+            for (int p : Profits) {
+                heap.add(p);
+                if (heap.size() > k) heap.poll();
+            }
+            for (int h : heap) W += h;
+            return W;
+        }
+
+        int idx;
+        int n = Profits.length;
+        for (int i = 0; i < Math.min(k, n); ++i) {
+            idx = -1;
+            // 找到获取利润最多的项目
+            for (int j = 0; j < n; ++j) {
+                if (W >= Capital[j]) {
+                    if (idx == -1) idx = j;
+                    else if (Profits[idx] < Profits[j]) idx = j;
+                }
+            }
+            // 找不到合适的项目
+            if (idx == -1) break;
+            // 累计当前项目的利润到总利润中，并把当前项目标记为"不可用"（设置成最大整数）
+            W += Profits[idx];
+            Capital[idx] = Integer.MAX_VALUE;
+        }
+        return W;
+    }
+} 

solution/1100-1199/1117.Building H2O/Solution.java

@@ -0,0 +1,24 @@
+class H2O {
+
+    private Semaphore h = new Semaphore(2);
+    private Semaphore o = new Semaphore(0);
+    public H2O() {
+
+    }
+
+    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+
+        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
+        h.acquire();
+        releaseHydrogen.run();
+        o.release();
+    }
+
+    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+
+        // releaseOxygen.run() outputs "O". Do not change or remove this line.
+        o.acquire(2);
+        releaseOxygen.run();
+        h.release(2);
+    }
+}

solution/1100-1199/1195.Fizz Buzz Multithreaded/Solution.java

@@ -0,0 +1,60 @@
+class FizzBuzz {
+    private int n;
+
+    public FizzBuzz(int n) {
+        this.n = n;
+    }
+
+    private Semaphore fSema = new Semaphore(0);
+    private Semaphore bSema = new Semaphore(0);
+    private Semaphore fbSema = new Semaphore(0);
+    private Semaphore nSema = new Semaphore(1);
+
+    // printFizz.run() outputs "fizz".
+    public void fizz(Runnable printFizz) throws InterruptedException {
+        for (int i = 3; i <= n; i = i + 3) {
+            if (i % 5 != 0) {
+                fSema.acquire();
+                printFizz.run();
+                nSema.release();
+            }
+        }
+    }
+
+    // printBuzz.run() outputs "buzz".
+    public void buzz(Runnable printBuzz) throws InterruptedException {
+        for (int i = 5; i <= n; i = i + 5) {
+            if (i % 3 != 0) {
+                bSema.acquire();
+                printBuzz.run();
+                nSema.release();
+            }
+        }
+    }
+
+    // printFizzBuzz.run() outputs "fizzbuzz".
+    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
+        for (int i = 15; i <= n; i = i + 15) {
+            fbSema.acquire();
+            printFizzBuzz.run();
+            nSema.release();
+        }
+    }
+
+    // printNumber.accept(x) outputs "x", where x is an integer.
+    public void number(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            nSema.acquire();
+            if (i % 3 == 0 && i % 5 == 0) {
+                fbSema.release();
+            } else if (i % 3 == 0) {
+                fSema.release();
+            } else if (i % 5 == 0) {
+                bSema.release();
+            } else {
+                printNumber.accept(i);
+                nSema.release();
+            }
+        }
+    }
+}