剑指offer2

Author: JavaScalaDeveloper

change/note/多线程.md

@@ -779,59 +779,44 @@ public class AlternatePrinting {
 
 ```java
 class PrintABC {
-    private static final Object lock = new Object();
-    private static int state = 0;
+private static final Object lock = new Object();
+private static int state = 0;
 
-    public static class ThreadA extends Thread {
-        public void run() {
-            try {
-                synchronized (lock) {
-                    for (int i = 0; i < 10; i++) {
-                        while (state % 3 != 0)
-                            lock.wait();
-                        System.out.print("A");
-                        state++;
-                        lock.notifyAll();
-                    }
-                }
-            } catch (InterruptedException e) {
-                e.printStackTrace();
+public static class ThreadA extends Thread {
+    public void run() {
+        synchronized (lock) {
+            for (int i = 0; i < 10; i++) {
+                while (state % 3 != 0) lock.wait();
+                System.out.print("A");
+                state++;
+                lock.notifyAll();
             }
         }
     }
+}
 
     public static class ThreadB extends Thread {
         public void run() {
-            try {
-                synchronized (lock) {
-                    for (int i = 0; i < 10; i++) {
-                        while (state % 3 != 1)
-                            lock.wait();
-                        System.out.print("B");
-                        state++;
-                        lock.notifyAll();
-                    }
+            synchronized (lock) {
+                for (int i = 0; i < 10; i++) {
+                    while (state % 3 != 1) lock.wait();
+                    System.out.print("B");
+                    state++;
+                    lock.notifyAll();
                 }
-            } catch (InterruptedException e) {
-                e.printStackTrace();
             }
         }
     }
 
     public static class ThreadC extends Thread {
         public void run() {
-            try {
-                synchronized (lock) {
-                    for (int i = 0; i < 10; i++) {
-                        while (state % 3 != 2)
-                            lock.wait();
-                        System.out.print("C");
-                        state++;
-                        lock.notifyAll();
-                    }
+            synchronized (lock) {
+                for (int i = 0; i < 10; i++) {
+                    while (state % 3 != 2) lock.wait();
+                    System.out.print("C");
+                    state++;
+                    lock.notifyAll();
                 }
-            } catch (InterruptedException e) {
-                e.printStackTrace();
             }
         }
     }
@@ -1285,23 +1270,18 @@ public class BoundedBuffer {
         while (buffer.size() == maxSize) {  // 当缓冲区已满时，生产者等待
             wait();
         }
-
         buffer.add(item);
         System.out.println("Produced: " + item);
-
         notifyAll();  // 唤醒所有等待的线程（包括生产者和消费者）
     }
 
     public synchronized int consume() throws InterruptedException {
         while (buffer.size() == 0) {  // 当缓冲区为空时，消费者等待
             wait();
         }
-
         int item = buffer.remove();
         System.out.println("Consumed: " + item);
-
         notifyAll();  // 唤醒所有等待的线程（包括生产者和消费者）
-
         return item;
     }
 }

change/note/常用算法的解题思路.md

@@ -28,65 +28,55 @@
 
 Java中可以使用位运算来实现二进制加减乘除运算。具体实现如下：
 
-## 二进制加法
-
-二进制加法可以使用上述的位运算实现。假设需要对两个二进制数a和b进行加法运算，可以使用如下代码：
-
-```java
-int result=0; // 存储计算结果
-        int carry=0; // 存储进位结果
-        while(b!=0){
-        result=a^b; // 不进位的结果
-        carry=(a&b)<<1; // 进位的结果
-        a=result;
-        b=carry;
-        }
-        System.out.println(a); // 输出计算结果
-```
-
-## 二进制减法
-
-二进制减法可以先将减数按位取反，然后加上1，最后进行二进制加法。具体实现如下：
+## 二进制加减乘除
 
 ```java
-int negate=~b+1; // 取反加1
-        int result=a+negate; // 二进制加法
-        System.out.println(result); // 输出计算结果
-```
-
-## 二进制乘法
+public class BinaryOperations {
+    // 二进制加法
+    public int add(int a, int b) {
+        while (b != 0) {
+            int carry = a & b; // 计算进位
+            a = a ^ b; // 计算无进位的和
+            b = carry << 1; // 左移进位，继续相加
+        }
+        return a;
+    }
 
-二进制乘法可以使用位运算中的左移运算（<<）和按位与运算（&）实现。假设需要对两个二进制数a和b进行乘法运算，可以使用如下代码：
+    // 二进制减法
+    public int sub(int a, int b) {
+        b = add(~b, 1); // 将减数取反再加1，转换为加法运算
+        return add(a, b);
+    }
 
-```java
-int result=0; // 存储计算结果
-        while(b!=0){
-        if((b&1)==1){ // 如果b的最低位是1
-        result+=a; // 将a加到计算结果中
-        }
-        a<<=1; // 左移一位
-        b>>=1; // 右移一位
+    // 二进制乘法
+    public static int binaryMultiplication(int a, int b) {
+        int product = 0;
+        while (b != 0) {
+            if ((b & 1) != 0) { // 如果b的最低位为1
+                product = binaryAddition(product, a); // 将a累加到结果中
+            }
+            a = a << 1; // a左移1位
+            b = b >>> 1; // b右移1位
         }
-        System.out.println(result); // 输出计算结果
-```
-
-## 二进制除法
-
-二进制除法可以使用位运算中的右移运算（>>）和按位与运算（&）实现。假设需要对两个二进制数a和b进行除法运算，可以使用如下代码：
+        return product;
+    }
 
-```java
-int quotient=0; // 商
-        int remainder=a; // 余数
-        while(remainder>=b){
-        int shift=0; // 移位数
-        while((b<<shift)<=remainder){ // 找到最大的移位数
-        shift++;
-        }
-        shift--; // 因为最后一次移位是多余的，所以需要减去1
-        quotient+=(1<<shift); // 将移位数加到商中
-        remainder-=(b<<shift); // 减去移位后的值
-        }
-        System.out.println(quotient); // 输出商
+    // 二进制除法
+    public static int binaryDivision(int a, int b) {
+        int quotient = 0;
+        int remainder = 0;
+        for (int i = 31; i >= 0; i--) {
+            int shiftedDividend = a >>> i; // a右移，获取商的位
+            remainder = remainder << 1; // 余数左移1位
+            remainder = remainder | (shiftedDividend & 1); // 余数的最低位更新为商的位
+            if (remainder >= b) {
+                remainder = remainder - b; // 更新余数
+                quotient = quotient | (1 << i); // 商的对应位设为1
+            }
+        }
+        return quotient;
+    }
+}
 ```
 
 # Java里int类型的2到16进制表示方法

change/scripts/Main.java

@@ -5,10 +5,11 @@
 import java.nio.file.attribute.BasicFileAttributes;
 
 public class MergeMdFiles {
+    private static final int EXPORT_SIZE=500;
 
     public static void main(String[] args) throws IOException {
         String directory = "D:\\WorkSpaces\\leetcode-all\\solution"; // 修改为目录路径
-        String outputFile = "D:\\WorkSpaces\\leetcode-all\\change\\scripts\\out\\leetcode-v2023.md"; // 修改为输出文件路径
+        String outputFile = "D:\\WorkSpaces\\leetcode-all\\change\\scripts\\out\\leetcode-"+EXPORT_SIZE+"-v2023.md"; // 修改为输出文件路径
 
         File dir = new File(directory);
         if (!dir.exists() || !dir.isDirectory()) {
@@ -31,14 +32,14 @@ private static void mergeMdFiles(File dir, OutputStream os) throws IOException {
             } else if (basicFileAttributes.isRegularFile() && file.getName().endsWith(".md")) {
 //                忽略solution根目录的文件
                 if (file.getPath().length() > 60) {
-//                    String num = file.getPath().substring(46, 50);
-//                    int no = Integer.parseInt(num);
+                    String num = file.getPath().substring(46, 50);
+                    int no = Integer.parseInt(num);
 //                    导出前2000道
-//                    if (no <= 2000) {
+                    if (no <= EXPORT_SIZE) {
                         FileInputStream fis = new FileInputStream(file);
                         copy(fis, os);
                         fis.close();
-//                    }
+                    }
 
                 }
             }

change/scripts/MergeMdFiles.java

@@ -0,0 +1,18 @@
+package change.scripts;
+
+import java.util.Arrays;
+
+/*
+非负整数数组，将元素随机排序，将所有元素连接起来形成一个新的数字，找到最小的数字
+010，100->10010
+5,56->556
+0,56->56
+ */
+public class Solution {
+    public static void main(String[] args) {
+    }
+
+
+}
+
+