每日一题.md · ethan/JavaDailyQuestions

## Java基础

### 2021-08-15（基本数据类型和位运算）

1. 列举java所有的基本数据类型、字节数和取值范围；
2. 实际运行一下或（ | ）、且（ & ）、非（ ~ ）、异或（ ^ ）、>>、<< 这几种运算符，比如：12 | 21 = 29，想想为什么会得到那样的运算结果，试着自己推演一下过程；
3. 冒泡排序算法，例如：给你 [10,4,2,7,5,19,11,33,28] 这样的数组，对它进行冒泡排序，然后按照从小到大输出新的数组。要求写出完整的可运行的代码，贴在答案里面。

### 2021-08-16（String类、类型转换和BigDecimal）

1. 请问：`String a = "12" + "34" + new String("12") + "1234" ; `创建了几个字符串对象？请试着从原理的层次分析一下为什么；
2. `short s1 = 1; s1 = s1 + 1;`会正确运行吗?` short s1 = 1; s1 += 1;`会正确运行吗？请问为什么会出现这样的结果？
3. `double a = 1d - 0.9d; double b = 0.9d - 0.8d; `请问` a == b` 成立吗？为什么？在Java中涉及到这样的精确计算应该怎么办？
4. 快速排序算法，例如：给你 [10,4,2,7,5,19,11,33,28] 这样的数组，对它进行快速排序，然后按照从小到大顺序排列输出新的数组。要求写出完整的可运行的代码，贴在答案里面。（有点难，作为扩展题，不强制要求）

### 2021-08-17 （类加载顺序）

1. （必做）有下面的一个类，请问最后main方法输出是什么？请试着分析打印输出的过程，写出自己的理解。

```java
   public class Book {
       static Book book = new Book();
       static int amount = 112;
       static {
           System.out.println("书的静态代码块");
           System.out.println("amount=" + amount);
       }
       int price = 110;
   
       {
           System.out.println("书的普通代码块");
       }
   
       Book() {
           System.out.println("书的构造方法");
           System.out.println("price=" + price + ",amount=" + amount);
       }
   
       public static void staticFunction() {
           System.out.println("书的静态方法");
       }
   
       public static void main(String[] args) {
           staticFunction();
       }
   
   }
   ```

2. （选做）有下面的一个类，请问最后main方法输出是什么？请试着分析打印输出的过程，写出自己的理解（warning！难度很大！）

```java
   public class Main {
       public static int k = 0;
       static Main t1 = new Main("t1");
       public static Main t2 = new Main("t2");
       public static int i = print("i");
       public static int n = 99;
       public int j = print("j");
   
       static {
           print("静态块");
       }
   
       public Main(String str) {
           System.out.println((++k) + ": " + str + " i=" + i + " n=" + n);
           ++i;
           ++n;
       }
   
       public static int print(String str) {
           System.out.println((++k) + ": " + str + " i=" + i + " n=" + n);
           ++n;
           return ++i;
       }
   
       public static void main(String[] args) {
           new Main("init");
       }
   }
   ```

### 2021-08-18 （简单的IO操作）

1. （必做）文件拷贝：在本地任意目录下新建 from.txt，内容如下：

> 你好，我是一只勤快的小蜜蜂
      >
      > 每天学习Java
      >
      > 我很Happy

请你编码将它从本地磁盘读取出来，将文件里面的内容、文件名称、文件大小（KB）输出到控制台，再将内容写到一个新的文件 to.txt 中，文件编码为 UTF-8。

2. （选做）在 files目录下有一个文件： `日落大道1.mp3`，但是这个文件的字节流被我处理过了，每个字节都是按照`x=255-x`进行处理的，所以它无法播放，请你读取文件字节流，对其重新操作生成正常可以播放的文件 `日落大道.mp3`。将代码贴在答案里面。

### 2021-08-19（多线程）

1. （必做）写出实现多线程的n种方式，编码测试。
   2. （选做）画出线程的生命周期图。

### 2021-08-20（多线程）

1. （必做）Java里面有几种内置的线程池？每种线程池有啥作用？线程池的参数了解吗？请说明下每个参数的作用。
   2. （选做）请写出生产-消费者模型完成银行转账。

### 2021-08-21（多线程）

1. （必做）请问：`i++` 是线程安全的吗？请编码模拟多线程并发操作测试，并贴出测试结果，思考为什么会出现这样的结果。
   2. （选做）（迅雷面试题）有三个线程，每个线程的 run方法里面打印自己的线程编号，例如 线程A打印 A，线程B打印B，线程C打印C，现要求每个线程循环执行10次打印操作，最后输出的结果是按顺序的 `ABC` 10个，请编程实现。（结果：ABCABCABCABC...，提示：可以用信号量来实现）

### 2021-08-22（多线程）

1. （必做）现在有3个线程A、B、C，请问，如何在B、C线程中获取到A线程操作共享变量后的结果？（例如共享变量num=0，在A中对其进行 +1操作，要求在线程B和C中获取A线程操作后的结果并打印num的值）（提示：使用Semaphore类）
   2. （选做）什么是线程死锁？产生死锁的条件是什么？写一个必定会死锁的例子，并找到破解死锁的办法。

### 2021-08-23（多线程）

1. （必做）synchronized关键字有哪些用法？请编码测试每种用法。
   2. （选做）什么是无锁、偏向锁、轻量级锁、重量级锁，简述synchronized锁升级的过程。

### 2021-08-24（JUC）

1. （必做）列举下你所知道的JUC里常用的类，最好在本地写代码测试下这些类的作用。

BlockingQueue、CopyOnWriteArrayList、CountDownLatch、 CyclicBarrier、 Semaphore

```java
   public class BlockingQueueTest {
   
       private static final ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(3);
   
       public static void main(String[] args) throws InterruptedException {
           //test1();
           //test2();
   
           test3();
   
       }
   
       /**
        * 这对方法 超过队列大小 继续向队列中添加值、移除值会抛异常
        * java.lang.IllegalStateException: Queue full
        */
       public static void test1(){
           queue.add("a");
           queue.add("b");
           queue.add("cd");
           //queue.add("d");
   
           System.out.println(queue.element());// a 获取队首元素
   
           queue.remove();
       }
   
       /**
        * 这对方法 操过队列大小 继续向队列中添加值、移除值不会抛异常
        */
       public static void test2(){
           //向队列中添加值
           queue.offer("a");
           queue.offer("b");
           queue.offer("c");
           queue.offer("d");
   
           System.out.println(queue.peek()); // 获取队首元素
   
           //从队列中移除值
           queue.poll();
       }
   
       /**
        *等待，阻塞（一直阻塞）
        */
       public static void test3() throws InterruptedException {
           ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
   
           //一直阻塞
           arrayBlockingQueue.put("a");
           arrayBlockingQueue.put("b");
           arrayBlockingQueue.put("c");
           //arrayBlockingQueue.put("d"); //队列没有位置了，一直阻塞
   
           System.out.println(arrayBlockingQueue.take());
           System.out.println(arrayBlockingQueue.take());
           System.out.println(arrayBlockingQueue.take());
           System.out.println(arrayBlockingQueue.take()); //没有数据了，一直阻塞
   
       }
   
       /**
        *等待，阻塞（等待超时） 阻塞一定时间，就不再阻塞
        */
       public static void test4() throws InterruptedException {
           ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
   
           arrayBlockingQueue.offer("a");
           arrayBlockingQueue.offer("b");
           arrayBlockingQueue.offer("c");
           arrayBlockingQueue.offer("d",2, TimeUnit.SECONDS); //等待两秒，超时退出
   
           System.out.println("******");
           System.out.println(arrayBlockingQueue.poll());
           System.out.println(arrayBlockingQueue.poll());
           System.out.println(arrayBlockingQueue.poll());
           arrayBlockingQueue.poll(2, TimeUnit.SECONDS); //等待两秒，超时退出
       }
   }
   ```

```java
   public class CountDownLatchDemo {
       public static void main(String[] args) {
           //减法计数器
           CountDownLatch countDownLatch = new CountDownLatch(5);
   
           for (int i = 1; i <= 5; i++) {
   
              new Thread(() -> {
                  System.out.println(Thread.currentThread().getName() +" GO!");
                  countDownLatch.countDown(); // -1
              },String.valueOf(i)).start();
           }
   
           try {
               countDownLatch.await(); //计数器归零，才会执行下面的代码
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           System.out.println("Close Door!");
       }
   }
   
   ```

![image-20210902094531797](D:\workspace\likelong's noteBook\imgs\image-20210902094531797.png)

```java
   /**
    * 停车位
    * 三个停车位 六辆车
    */
   public class SemaphoreDemo {
       public static void main(String[] args) {
           //三个停车位
           Semaphore semaphore = new Semaphore(3);
   
           //六个线程 模拟六辆车
           for (int i = 1; i <= 6; i++) {
               new Thread(()->{
                   try {
                       semaphore.acquire(); // 获得，如果已经满了，等待，等待被释放为止！
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName() + "进入停车位！");
                   
                   //停一会儿车
                   try {
                       TimeUnit.SECONDS.sleep(3);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
   
                   System.out.println(Thread.currentThread().getName() + "离开停车位！");
   
                   semaphore.release(); // 释放，会将当前的信号量释放+1，然后唤醒等待的线程！
               },String.valueOf(i)).start();
           }
       }
   }
   ```

![image-20210902095717734](D:\workspace\likelong's noteBook\imgs\image-20210902095717734.png)

1. （选做）CAS是什么？AtomicInteger使用了CAS机制，会出现什么问题？

> CAS：即 Compare -And- Swap  比较并交换；比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么执行操作！如果不是就一直循环，使用的是自旋锁。

```java
   public class AtomicIntegerTest {
       public static void main(String[] args) {
           AtomicInteger atomicInteger = new AtomicInteger(1);
   
           System.out.println(atomicInteger.compareAndSet(1, 2)); //true
           System.out.println(atomicInteger.get()); //2
           System.out.println(atomicInteger.getAndIncrement()); //2
           
           /*
               public final int getAndIncrement() {
                   return unsafe.getAndAddInt(this, valueOffset, 1);
               }
            */
       }
   }
   ```

**AtomicInteger：**此类里的方法都是直接或间接调用Unsafe类里的方法，Unsafe类里的方法都是native方法；Unsafe中的方法都是直接调用操作系统底层资源执行相应的任务，即操作系统底层原语，不容许被打断，不会造成所谓的数据不一致的问题。

CAS的**缺点**是什么？

循环时间长，CPU开销大。只能保证一个共享变量的一致性操作。不可避免的**ABA问题**。

![image-20210902101256134](D:\workspace\likelong's noteBook\imgs\image-20210902101256134.png)

**AtomicReference（原子引用）**可以解决ABA问题，解决思想：类似乐观锁，每次操作给版本号+1，版本号和之前一样才可继续操作。

### 2021-08-25（JUC）

1. （必做）synchronized 和 Lock 的区别是什么？在什么场景下使用这2者？

synchronized ：自动加锁、释放锁；Java内置关键字；适用于同步代码较少的场景

Lock ：手动加锁、释放锁（如果不释放锁就会发生死锁）；Java一个接口；适用于有大量同步代码的场景

1. （选做）设计一段程序，用semaphore 实现停车场提示牌功能：

每个停车场入口都有一个提示牌，上面显示着停车场的剩余车位还有多少，当剩余车位为0时，不允许车辆进入停车场，直到停车场里面有车离开停车场，这时提示牌上会显示新的剩余车位数。

**业务场景 ：**

1、停车场容纳总停车量10。

2、当一辆车进入停车场后，显示牌的剩余车位数响应的减1.

3、每有一辆车驶出停车场后，显示牌的剩余车位数响应的加1。

4、停车场剩余车位不足时，车辆只能在外面等待。

5、停车场有入口和出口，可以使用2个线程来模拟。

### 2021-08-26（JUC）

1. （必做）使用Condition实现生产-消费者模型（可以模拟售票操作，保证不会出现超卖）

```java
      /**
       * 生产者和消费者模式
       * 使用Condition实现生产-消费者模型（可以模拟售票操作，保证不会出现超卖）
       */
      public class ConditionTest {
          public static void main(String[] args) {
              Ticket ticket = new Ticket();
      
              //卖票
              new Thread(() -> {
                  for (int i = 0; i < 10; i++) {
                      ticket.sale();
                  }
      
              }, "T1").start();
      
              //生产票
              new Thread(() -> {
                  for (int i = 0; i < 10; i++) {
                      ticket.make();
                  }
              }, "T2").start();
          }
      }
      
      
      class Ticket {
      
          private final Lock lock = new ReentrantLock();
          //Condition 可以实现精确唤醒
          Condition condition1 = lock.newCondition();
          Condition condition2 = lock.newCondition();
      
          /**
           * 当前剩余票
           */
          private int num = 0;
      
          /**
           * 最大票数
           */
          private static final int MAX = 5;
      
          /**
           * 卖票操作
           */
          public void sale() {
              lock.lock();
              try {
                  //判断
                  while (num == 0) {
                      try {
                          //等待
                          condition1.await();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
                  TimeUnit.MILLISECONDS.sleep(700);
                  num--;
                  System.out.println(Thread.currentThread().getName() + "卖了1张票，还剩" + num + "张");
                  condition2.signalAll(); //唤醒其他线程
              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  lock.unlock();
              }
          }
      
          /**
           * 生产票操作
           */
          public void make() {
              lock.lock();
              try {
                  //判断
                  while (num == MAX) {
                      try {
                          //等待
                          condition2.await();
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                  }
                  TimeUnit.MILLISECONDS.sleep(500);
                  num++;
                  System.out.println(Thread.currentThread().getName() + "生产了1张票，还剩" + num + "张");
                  condition1.signalAll(); //唤醒其他线程
              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  lock.unlock();
              }
          }
      
      }
      ```

2. （选做）去了解下LockSupport这个类，它提供了哪些静态方法？分别是什么作用？它可以实现生产-消费者模型吗？

### 2021-08-27（JUC）

1. 简述`LongAdder` 对 `AtomicLong` 的改进的思路。
   2. 什么是AQS，在JUC里有哪些典型的AQS实现？

### 2021-08-28（集合）

1.请画出所有集合的继承关系图，并熟记常见的集合如ArrayList、LinkedList、HashMap等，了解其用法和使用场景。

| 单列集合                                                     |
   | ------------------------------------------------------------ |
   | ![image-20210902130443095](D:\workspace\likelong's noteBook\imgs\image-20210902130443095.png) |

| 双列集合                                                     |
   | ------------------------------------------------------------ |
   | ![image-20210902130702269](D:\workspace\likelong's noteBook\imgs\image-20210902130702269.png) |

2.ArrayList底层是什么数据结构，扩容如何实现的？它的特点是什么？在多线程环境中会出现什么问题？

底层是对象数组

> ArrayList扩容机制：

1、查看ArrayList的add方法，场景假设，一个list长度是10，目前有5个元素

```java
   public boolean add(E e) {
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       elementData[size++] = e;
       return true;
   }
   ```

size是目前的元素个数等于5。ensureCapacityInternal(size + 1)进行判断是否有增加1个元素的空间。

2、进行判断，目前minCapacity=6，elementData是此时的数组。

如果增加元素后的数组长度比数组长度大，就进行扩容。

![image-20210902131610996](D:\workspace\likelong's noteBook\imgs\image-20210902131610996.png)

3、扩容原来数组长度的1.5倍，创建新的数组，把原来的数组数据copy到新的数组里面。

```java
       private void grow(int minCapacity) {
           // overflow-conscious code
           int oldCapacity = elementData.length;
           int newCapacity = oldCapacity + (oldCapacity >> 1);
           if (newCapacity - minCapacity < 0)
               newCapacity = minCapacity;
           if (newCapacity - MAX_ARRAY_SIZE > 0)
               newCapacity = hugeCapacity(minCapacity);
           // minCapacity is usually close to size, so this is a win:
           elementData = Arrays.copyOf(elementData, newCapacity);
       }
   ```

### 2021-08-29（集合）

HashMap底层的数据结构是什么？它插入的原理是什么？为什么它不是线程安全的？JDK1.7和1.8的HashMap有什么区别？

JDK1.8 之前 HashMap 由 **数组+链表** 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。 JDK1.8 以后的 `HashMap` 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）（将链表转换成红黑树前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树）时，将链表转化为红黑树，以减少搜索时间。

**插入原理：**

**1.计算关于key的hashcode值（与Key.hashCode的高16位做异或运算）**

**2.如果散列表为空时，调用resize()初始化散列表**

**3.如果没有发生碰撞，直接添加元素到散列表中去**

**4.如果发生了碰撞(hashCode值相同)，进行三种判断**

**4.1:若key地址相同或者equals后内容相同，则替换旧值**

**4.2:如果是红黑树结构，就调用树的插入方法**

**4.3：链表结构，循环遍历直到链表中某个节点为空，尾插法进行插入，插入之后判断链表个数是否到达变成红黑树的阙值8；也可以遍历到有节点与插入元素的哈希值和内容相同，进行覆盖。**

**5.如果桶满了大于阀值，则resize进行扩容**

HashMap为什么是线程不安全的？

在JDK1.8中，在并发执行put操作时会发生数据覆盖的情况

### 2021-08-30（集合）

你了解的线程安全的集合有哪些？在哪些场景可以使用？

Vector：就比ArrayList多了个同步化机制（线程安全）

CopyOnWriteArrayList：有序、可重复

CopyOnWriteArraySet：无序、不可重复

ConcurrentHashMap：键值对

### 2021-08-31（集合）

循环删除集合里面的元素，你能写出几种？

**3种：**

- 普通for循环

```java
           List<String> list = new ArrayList<>();
           list.add("a");
           list.add("b");
           list.add("c");
   
           /*
           1、for循环遍历list
            */
           for (int i = 0; i < list.size(); i++) {
               if (list.get(i).equals("b"))
                   list.remove(i);
           }
   ```

- 增强for循环

```java
           List<String> list = new ArrayList<>();
           list.add("a");
           list.add("b");
           list.add("c");
     	    /*
           2、增强for循环
            */
           for (String s : list) {
               if("b".equals(s)){
                   list.remove(s);
               }
           }
   ```

- iterator迭代器遍历

```java
        List<String> list = new ArrayList<>();
           list.add("a");
           list.add("b");
           list.add("c");
           /*
           3、iterator遍历
            */
           Iterator<String> iterator = list.iterator();
           while (iterator.hasNext()) {
               String s = iterator.next();
               if ("b".equals(s)) {
                   iterator.remove();
               }
           }
   ```

**面试题：集合中放入7个元素 怎么用一次for循环删除前4个元素**

分析：每次移除一个元素，集合长度就会-1，后面的元素都会向前移动一个位置，就是这个元素后所有元素的下标减一。

```java
   /**
    * 集合中放入7个元素 怎么用一次for循环删除前4个元素
    * 
    * 正确结果：[da, bb, yyy]
    */
   public class Test {
       public static void main(String[] args) {
           List<String> list = new ArrayList<>();
           list.add("ace");
           list.add("bbb");
           list.add("aaa");
           list.add("acd");
           list.add("da");
           list.add("bb");
           list.add("yyy");
   
           /*
           错误结果：[bbb, acd, bb]
           分析：每次移除一个元素，集合长度就会-1，后面的元素都会向前移动一个位置，就是这个元素后所有元素的下标减一。
            */
   //        for (int i = 0; i < list.size(); i++) {
   //            if (i <= 4) {
   //                list.remove(i);
   //            }
   //        }
   
           int sign = 0;
           for (int i = 0; i < list.size(); i++) {
               list.remove(i); //每次移除一个元素，后面的元素都会向前移动一个位置
               i--; //保证每次移除都是第一个元素
               sign++;
               if (sign == 4) {
                   break; //结束循环条件，移除前4个元素
               }
           }
   
           System.out.println(list);
       }
   }
   ```

### 2021-09-01（反射）

有一个Person类，包含name、age、sex等属性，使用反射创建Person对象，并调用setName、setAge等方法设置属性值，最后打印Person对象的属性信息。

<<<<<<< HEAD
   ```java
   public class ReflectTest {
       public static void main(String[] args) throws Exception {
           Person person = Person.class.newInstance();
   
           person.setName("likelong");
           person.setAge(21);
           System.out.println(person);
       }
   }
   ```
=======
## MySQL

### 	2021-09-02

请创建一个表 `user`，包含`id`、`username`、`password`、`real_name`、`age`、`sex`等字段，写出创建表的sql语句并在mysql客户		端执行成功。
>>>>>>> ae5fadf15b8870836527b259c7326ce2c27c53df

## JVM

1.请问Java源代码 .java文件从编译成.class文件到运行出结果，这中间发生了什么？请画图说明一下，越详细越好！

2.画一下Jdk1.8的内存区域图。最好能标出每个区域内部的结构，越详细越好！

![image-20210902153504688](D:\workspace\likelong's noteBook\imgs\image-20210902153504688.png)

3.Java有哪些类加载器？作用分别是什么？如何自定义类加载器？为什么要自定义类加载器？请编码实现一个自定义的类加载器。

Bootstrap ClassLoader

Extension ClassLoader

Application ClassLoader

4.什么情况下会触发类加载？请列举（至少写出5种，例如：new 一个对象实例触发类加载）

5.JVM常见的堆内存包含哪些区域，每个区域有什么作用？一般常见的JVM参数设置有哪些？

![image-20210902154559867](D:\workspace\likelong's noteBook\imgs\image-20210902154559867.png)

## 设计模式（23种）

> 设计模式遵循六⼤原则；单⼀职责( ⼀个类和⽅法只做⼀件事 )、⾥⽒替换( 多态，⼦类可扩展⽗类 )、依赖
>
> 倒置( 细节依赖抽象，下层依赖上层 )、接⼝隔离( 建⽴单⼀接⼝ )、迪⽶特原则( 最少知道，降低耦合 )、开闭
>
> 原则( 抽象架构，扩展实现 )，

### 创建型模式（5）

- 单例模式（Singleton）
- 原型模式（Prototype）
- 工厂方法模式（Factory Method）
- 抽象工厂模式（AbstractFactory）
- 建造者模式（Builder）

### 结构型模式（7）

- 代理模式（Proxy）
- 适配器模式（Adapter）
- 桥接模式（Bridge）
- 装饰模式（Decorator）
- 外观模式（Facade）
- 享元模式（Flyweight）
- 组合模式（Composite）

### 行为模式（11）

- 模板方法模式（Template Method）
- 策略模式（Strategy）
- 命令模式（Command）
- 职责链模式（Chain of Responsibility）
- 状态模式（State）
- 观察者模式（Observer）
- 中介者模式（Mediator）
- 迭代器模式（Iterator）
- 访问者模式（Visitor）
- 备忘录模式（Memento）
- 解释器模式（Interpreter）

## 算法与数据结构
   简介：
> 数据结构和算法息息相关，不能单学算法。
> 本模块学习时间预计两个月，
> 后续会增加相关数据结构对应的算法题

### 数据结构
- 稀疏表
- 栈
- 队列
- 循环队列
- 单向链表
- 双向链表
- 单项循环链表
- 二叉树
- AVL 平衡二叉树
- BST 二叉排序树
- Huffman 哈夫曼树
- 图

### 算法
- 排序算法
> 0. 递归 （以下算法很多都需要递归知识）
> 1. 冒泡排序
> 2. 插入排序
> 3. 选择排序
> 4. 希尔排序
> 5. 快速排序
> 6. 归并排序
> 7. 堆排序 （需具备二叉树知识）
> 8. 桶排序  （只研究正整数，有能力的可以拓展）
- 递归训练
> 1. 八皇后问题 （需具备递归，稀疏表，数学斜率知识 tip: 判断两点所连直线斜率的绝对值是否为1）
> 2. 二叉树的先序、中序、后续遍历 （需具备递归和二叉树知识）

-- 后续补充，目前并不完整

ethan/JavaDailyQuestions

简介

发行版

贡献者

近期动态

ethan/JavaDailyQuestions .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

ethan/JavaDailyQuestions