4. 例题

● 小白上楼梯(递归设计)

import java.util.Scanner;public class demo06 {public static int f(int n) {if(n == 0)return 1;if(n == 1)return 1;if(n == 2)return 2;return f(n-1)+f(n-2)+f(n-3);}public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();System.out.println(f(n));}
}

● 旋转数组的最小数字(改造二分法)

public class demo07 {public static int min(int[] arr) {int left = 0;int right = arr.length - 1;// 若arr无旋转if(arr[left] < arr[right])return arr[left];// 当left和right相邻时，退出循环while(left + 1 < right) {int mid = left + ((right - left)>>1);if(arr[left] <= arr[mid]) {  // 左侧有序left = mid;}else {                      // 右侧有序right = mid;}}return right;}// 测试public static void main(String[] args) {int[] arr = {5, 1, 2, 3, 4};int res = min(arr);System.out.println(res);System.out.println();arr = new int[]{2, 3, 4, 5, 6};res = min(arr);System.out.println(res);System.out.println();// 数组元素重复出现时，判断不正确arr = new int[]{1, 0, 1, 1, 1};res = min(arr);System.out.println(res);System.out.println();}
}

LeetCode 上有道差不多相同的题，还有数组出现重复的题。

● 在有空字符串的有序字符串数组中查找

public class demo08 {private static int indexOf(String[] arr, String p) {int left = 0;int right = arr.length - 1;while(left < right) {int mid = left + ((right - left)>>1);while(arr[mid].equals("")){mid++;if(mid > right)return -1;}if(arr[mid].compareTo(p)>0)right = mid - 1;else if(arr[mid].compareTo(p)<0)left = mid + 1;elsereturn mid;}return -1;}// 测试public static void main(String[] args) {String[] arr = {"a", "", "ac", "", "ad", "b", "", "ba"};int res = indexOf(arr, "abc");System.out.println(res);}
}

● 最长连续递增子序列(部分有序)

用双指针

● 设计一个高效的求a的n次幂的算法

public class demo09 {public static void main(String[] args) {int n = 15;int a = 2;int res = pow0(a, n);System.out.println(Math.pow(a, n));System.out.println(res);res = pow(a, n);System.out.println(res);}// O(n)private static int pow0(int a, int n) {int res = 1;while (n > 0) {res *= a;n--;}return res;}// O(log(n))private static int pow(int a, int n) {if(n == 0)return 1;int res = a;int p = 1;while((p<<1) <= n) { // 指数乘2后小于n时继续res *= res;  // 按照指数倍增p <<= 1;    // p乘2}// 剩下n-p指数没算,递归计算return res*pow(a, n-p);}
}

---

● 调整数组顺序使奇数位于偶数前面

• 可用快排，左边找偶数，右边找奇数，然后对调
• 可以用归并，开辟辅助空间，一次扫描，奇数放左，偶数放右

import java.util.Arrays;public class demo10 {private static int[] helper;private static void Sort(int[] arr) {helper = new int[arr.length];System.arraycopy(arr, 0, helper, 0, arr.length);int left = 0, right = arr.length - 1;for(int val : helper) {if(val % 2 == 0)arr[right--] = val;else arr[left++] = val;}}// 测试public static void main(String[] args){int[] arr = {51,2,35,64,55,14,34,28,9};System.out.print("排序前：");System.out.println(Arrays.toString(arr));System.out.print("调整奇偶顺序后：");Sort(arr);}
}

● 第 k 个元素

• 方法一：直接先排序，再返回要求的第k个元素（如快排，时间复杂度O(nlogn)。

• 方法二：利用快排，每轮主元位置与k判断，每次可砍掉一半（时间复杂度一般情况为O(n)，最差O(n ²) )。

  补充：几何级数
  1+x+x2+...+xn=xn+1−1x−11+x+x^{2}+...+x^{n}=\frac{x^{n+1}-1}{x-1} 1+x+x2+...+xn=x−1xn+1−1​
  x 小于 1 时，取极限得值为 1/（1-x）。

import java.util.Arrays;public class demo11 {/*** @param A 数组* @param p 开始下标* @param r 结束小标* @param k 求第k小元素（递增第k个元素）*/public static int selectK(int[] arr, int p, int r, int k) {int q = partition(arr, p, r);int qk = q - p + 1;      // arr[q]为（按顺序排后）第几个值if(qk == k)    return arr[q];      else if(qk > k) return selectK(arr, p, q - 1, k);    // 若k比qk小，说明在arr[qk]左侧区域else return selectK(arr, q + 1, r, k - qk);             // 若k比qk大，说明在arr[qk]右侧区域}private static int partition(int[] arr, int p, int r) { // 和快排的一样int pivot = arr[p];int left = p + 1, right = r;while(left <= right) {if(arr[left] <= pivot)    left++;else {swap(arr, left, right);right--;}}swap(arr, p, right);return right;}private static void swap(int[] arr, int a, int b) {int temp = arr[a];arr[a] = arr[b];arr[b] = temp;}// 测试public static void main(String[] args) {int[] arr = {3, 9, 7, 6, 1, 2};System.out.print("原数组：");System.out.println(Arrays.toString(arr));int k = selectK(arr, 0, arr.length - 1, 4);System.out.println(k);Arrays.sort(arr);System.out.print("Arrays.sort排序后：");System.out.println(Arrays.toString(arr));}
}

● 超过一半的数字

• 方法一：排序后返回 arr[n/2]，使用快排复杂度为O(nlogn)
• 方法二：hash统计
• 方法三：排序统计，顺序下第 n/2 个一定是超过一半的那个数，与上一题类似，复杂度O(n)
• 方法四：不同的数进行消除，“寻找发帖 ’ 水王‘ ”题目

import java.util.Arrays;
public class demo12 {public static void solve1(int[] arr) {Arrays.sort(arr);System.out.println(arr[arr.length / 2]);}public static void solve4(int[] arr) {int candidate = arr[0]; // 候选数，先定位第一个元素int times = 1;   // 出现的次数 for(int i = 1; i < arr.length; i++) {if(times == 0) {candidate = arr[i];times = 1;continue;}if(arr[i] == candidate) times++;else times--;}System.out.println(candidate);}public static void main(String[] args) {solve1(new int[]{0, 1, 2, 1, 1});solve4(new int[]{0, 1, 2, 1, 1});}
}

变化：若出现次数恰好为数组的一半 ？

思路：

水王占总数的一半，说明总数必为偶数；

不失一般性，假设隔一个数就是水王的id，两两不同最后一定会消减为0；

水王可能是最后一个元素，每次扫描的时候，多一个动作，和最后一个元素做比较，单独计数，计数恰好等于一半；

如果不是，计数不足一半，那么去掉最后一个元素，水王就是留下的那个candidate；

public static void solve5(int[] arr) {int candidate = arr[0];int times = 1;int countLast = 0;for(int i = 1; i < arr.length; i++) {// 增加和最后一个元素比较的步骤if(arr[i] == arr[arr.length-1])    countLast++;  // 水王可能是最后一个元素,统计最后一个元素出现次数if(times == 0) {candidate = arr[i];times = 1;continue;}if(arr[i] == candidate) times++;else times--;}// 最后一个元素出现次数是n/2,则直接返回if(countLast == arr.length/2) System.out.println(arr[arr.length-1]);else System.out.println(candidate);
}

● 最小可用ID

• 暴力解法

//  O(N²) 暴力解法:从1开始依次探测每个自然数是否在数组中
public static int find1(int[] arr) {int i = 1;while(true) {int flag = 0;for(int j : arr) {if(j == i) {  // 若在数i在数组中flag = 1;continue;} }if(flag == 0) return i;i++;}
}

• 先快排，再找

  快排可直接使用 Arrays.sort()!

// O(NlogN)
public static int find2(int[] arr) {Arrays.sort(arr);for(int i = 0; i < arr.length; i++) if(arr[i] != i + 1)    return i+1;    return arr.length+1;
}

• 用辅助数组

  一次循环，用辅助数组下标表示原数组中的数值，辅助数组值用0、1表示是否存在；

  再一次循环找辅助数组中第一个0值；

  注意：要如果原数组元素中出现大于数组长度的值，它不可能是要找的那个值，如【1，2，3，10】，中，10大于数组长度4，要返回的数值在10之前（返回4）。

public static int find3(int[] arr) {int len = arr.length;int[] helper = new int[len + 1]; // 辅助数组for(int i = 0; i < len; i++) {if(arr[i] <= len) {helper[arr[i]] = 1;  }}for(int i = 1; i < len + 1; i++) { // 辅助数组从下标为1开始(因为arr中最小的数从1开始)if(helper[i] == 0)  return i;}return n + 1;
}

• 分区，递归

  问题可转化为：n个正数的数组A，如果存在小于n的数不在数组中，必然存在大于n的数在数组中， 否则数组排列恰好为1到n。

  借助 “ 第k个元素 ” 题目的 selectK 方法，每轮找出区域内中实际的中值，判断实际的中值是否与中间下标(mid+1)相同，若相同则mid左区域稠密，对右侧进行查找；否则对左侧进行查找。

public static int find4(int[] arr, int l, int r) {if(l > r)return l + 1;int mid = l + ((r - l) >> 1);    // 数组的中央下标int midVal = selectK(arr, l, r, mid - l + 1);   // 实际排中间的值int midIdx = mid + 1;   // 从1开始的，加上1if(midVal == midIdx)   // 左侧紧密return find4(arr, mid + 1, r);else                  // 左侧稀疏return find4(arr, l, mid - 1);
}

● 合并有序数组

三个指针，current指向A的末端，pa指向A数值末端，pb指向B末端，A、B的数从末端开始比较，然后填入current指向空间。

方法和归并排序中归并步骤基本相同。

import java.util.Arrays;public class demo14 {public static void merge(int[] A, int[] B) {int current = A.length - 1;int pa = A.length - B.length - 1;int pb = B.length - 1;while(pa >= 0 && pb >= 0) {if(A[pa] >= B[pb]) A[current--] = A[pa--];elseA[current--] = B[pb--];}while(pb >= 0) {A[current--] = B[pb--];}}public static void main(String[] args) {int[] A = new int[]{1,4,5,7,9,10,11,12,0,0,0,0,0};int[] B = new int[]{2,4,6,8,10};merge(A, B);System.out.println(Arrays.toString(A));}
}

● 逆序对个数

• 可以用双层循环遍历数组，找每个数有多少个逆序对
• 也可以在归并排序的merge过程中，抓住右侧的数找到逆序对个数。左右两区域域内有序，arr[left] > arr[right] 时，此时有 mid - left + 1 个逆序对，进行累加即可得到总的逆序对。

import java.util.Arrays;
public class demo15 {private static int[] helper;private static int count;  // 记录逆序对个数public static void sort(int[] arr) {helper = new int[arr.length];mergeSort(arr, 0, arr.length-1);}public static void mergeSort(int[] arr, int p, int r) {if(p < r) {int mid = p + ((r - p) >> 1);mergeSort(arr, p, mid);mergeSort(arr, mid + 1, r);merge(arr, p, mid, r);}}public static void merge(int[] arr, int p, int mid, int r) {System.arraycopy(arr, p, helper, p, r - p + 1);int left = p, right = mid + 1;int current = p;while(left <= mid && right <= r) {if(helper[left] <= helper[right])arr[current++] = helper[left++];else {arr[current++] = helper[right++];count += mid - left + 1; // 左边区域中，有多少个数大于当前helper[right]}}while(left <= mid) arr[current++] = helper[left++];}// 测试public static void main(String[] args){int[] arr = {51,2,35,64,55,14,34,28,9};System.out.print("排序前：");System.out.println(Arrays.toString(arr));System.out.print("MergeSort排序后：");sort(arr);System.out.println(Arrays.toString(arr));System.out.println("逆序对个数为：" + count);}
}

● 排序数组中找和的因子

• 方法一：对每一个arr[i]，k-arr[i]为要找的数，用二分查找对arr[i]后的数进行查找
• 方法二：左右两个指针left、right，arr[left]+arr[right]的值与k进行比较，若大于k，left++；等于k，输出二元组，left++、right–；若小于k，right–。left＞=right时退出

● 需排序的最短子数组

• 若数组要顺序排序时：

// 升序
public static int find_up(int[] arr) {int n = arr.length;int p1 = -1, p2 = -1;   // 乱序段的左右指针int max = arr[0];       // 乱序最大峰int min = arr[n - 1];  // 乱序最低峰// 拓展右端点：// 更新历史最高，只要右侧出现比历史最高低的，就应该将右边界扩展到此处for(int i = 1; i < n; i++) {if(arr[i] > max)max = arr[i];if(arr[i] < max)p2 = i;}// 找左端点：// 更新历史最低，只要左侧出现比历史最低高的，就应该将左边界扩展到此处for(int i = n - 2; i >= 0; i--) {if(arr[i] < min)min = arr[i];if(arr[i] > min)p1 = i;}// 若数组本身为排好序的(顺序)if(p1 == -1)return 0;System.out.println(p1 + ":" + p2);return p2 - p1 + 1;
}

测试：

// 测试
public static void main(String[] args) {reArrange obj = new reArrange();int[] A = {1, 4, 6, 5, 9, 10};int res = obj.find_up(A);System.out.println(res);System.out.println("===");A = new int[]{1, 2, 3, 4, 5, 6};res = obj.find_up(A);System.out.println(res);System.out.println("===");A = new int[]{1, 5, 3, 4, 2, 6, 7};res = obj.find_up(A);System.out.println(res);System.out.println("===");A = new int[]{2, 3, 7, 5, 4, 6};res = obj.find_up(A);System.out.println(res);System.out.println("===");A = new int[]{3, 2, 5, 6, 7, 8};res = obj.find_up(A);System.out.println(res);System.out.println("===");A = new int[]{2, 8, 7, 10, 9};res = obj.find_up(A);System.out.println(res);System.out.println("===");A = new int[]{2, 3, 7, 4, 1, 5, 6};res = obj.find_up(A);System.out.println(res);
}

• 若数组要逆序排序时：

// 逆序
public static int find_down(int[] arr) {int n = arr.length;int p1 = -1, p2 = -1;int max = arr[n - 1];int min = arr[0];// 拓展左端点：// 更新历史最高，只要左侧出现比历史最高低的，就应该将左边界扩展到此处for(int i = n - 2; i >= 0; i--) {if(arr[i] > max)max = arr[i];if(arr[i] < max)p1 = i;}// 拓展右端点：for(int i = 1; i < n; i++) {if(arr[i] < min)min = arr[i];if(arr[i] > min)p2 = i;}// 若数组本身为排好序的(顺序)if(p1 == -1)return 0;System.out.println(p1 + ":" + p2);return p2 - p1 + 1;
}

测试

// 测试
public static void main(String[] args) {reArrange obj = new reArrange();int[] A = {10, 1, 4, 6, 5, 9};int res = obj.find_down(A);System.out.println(res);System.out.println("===");A = new int[]{6, 5, 4, 3, 2, 1};res = obj.find_down(A);System.out.println(res);
}

• 顺序和逆序所得结果进行比较，选择长度短的输出

public static int find(int[] arr) {int l1 = find_up(arr);int l2 = find_down(arr);return l1 > l2 ? l2 : l1;
}// 测试
public static void main(String[] args) {reArrange obj = new reArrange();int[] A = {1, 5, 2, 3};int res = obj.find(A);System.out.println(res);
}

● 小顶堆与topK问题

• 维护一个大小为k的最小堆，输入前k个x先放入堆中，后续输入的x与堆顶比较，若小于堆顶元素，则不可能是topK；若大于堆顶元素，则将x与堆顶元素交换，进行堆的维护。

private static int k;
private static int[] heap;
private static int index = 0;  // 记录堆中有几个元素public static void main(String[] args) {Scanner sc = new Scanner(System.in);k = sc.nextInt();heap = new int[k];int x = sc.nextInt();while(x != -1) {deal(x);x = sc.nextInt();}System.out.println(Arrays.toString(heap));
}/*** 如果数据数量小于等于k，直接加入堆中* 等于k的时候，进行堆化* @param x*/
public static void deal(int x) {if(index < k){heap[index++] = x;if(index == k)makeMinHeap(heap);    // 建堆}else {if(heap[0] < x) {    // x与堆顶比较，若x大于堆顶，进行替换heap[0] = x;minHeapFixDown(heap, 0, k);System.out.println(Arrays.toString(heap));}}
}

partition 和 堆 都能解决顺序统计量问题，堆更适用于 海量数据流。

● 所有员工年龄排序

• 使用计数排序即可

● 数组能排成的最小数(特殊排序)

• 使用Arrays.sort进行排序，比较方法通过 比较器类对象 来自定义。

import java.util.Arrays;
import java.util.Comparator;public class minCombineNum {public static void main(String[] args) {int res = combine(new Integer[]{3, 32, 321});System.out.println(res);}public static int combine(Integer[] arr) {// 使用比较器自定义比较规则Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {String s1 = o1 + "" + o2;String s2 = o2 + "" + o1;return s1.compareTo(s2);}});StringBuilder sb = new StringBuilder();for(int i = 0; i < arr.length; i++) {sb.append(arr[i]);}return Integer.parseInt(sb.toString());}
}

计数排序适用于数据 范围小且已知。

● 字符串(数组)的包含

• 直接循环查找

public static boolean check(String s1, String s2) {for(int i = 0; i < s1.length(); i++) {char a = s1.charAt(i);   // 字符串中s1[i]的字符if(s2.indexOf(a) == -1)    // a不在s2中return false;}return true;
}

• 对s2先进行排序，之后使用二分查找降低复杂度

public static boolean check(String s1, String s2) {// 对s2转为数组型后进行快排char[] s2_arr = s2.toCharArray();Arrays.sort(s2_arr);// 判断s1中的字符是否出现在字符串s2中for(int i = 0; i < s1.length(); i++) {char a = s1.charAt(i);int index = Arrays.binarySearch(s2_arr, a);   // 二分查找，返回下标if(index < 0)return false;}return true;
}

5. 一些补充

• 当前时间

  long now = System.currentTimeMillis();
  

树的一些知识点

• 用数组tree表示一棵二叉树

  若tree[0]为根结点，对于结点 i ，其左孩子下标为 2i+1，右孩子下标为 2i+2，父结点下标为 ( i-1) / 2；

  若tree[1]为根结点，对于结点 i ，其左孩子下标为 2i，右孩子下标为 2i+1，父结点下标为 i / 2.

• 遍历方法：

  // 先序遍历
  public static void preOrder(int[] arr, int index) {if(index >= arr.length) return;System.out.println(arr[index]);preOrder(arr, index*2+1);preOrder(arr, index*2+2);
  }// 中序遍历
  public static void inOrder(int[] arr, int index) {if(index >= arr.length) return;inOrder(arr, index*2+1);System.out.println(arr[index]);inOrder(arr, index*2+2);
  }// 后序遍历
  public static void postOrder(int[] arr, int index) {if(index >= arr.length) return;postOrder(arr, index*2+1);postOrder(arr, index*2+2);System.out.println(arr[index]);
  }
  

  测试：

  public static void main(String[] args) {int[] arr = {78, 56, 34, 43, 4, 1, 15, 2, 23};System.out.print("层序遍历："+Arrays.toString(arr));System.out.println("\n==============");System.out.print("先序遍历：");preOrder(arr, 0);System.out.println("\n==============");System.out.print("中序遍历：");inOrder(arr, 0);System.out.println("\n==============");System.out.print("后序遍历：");postOrder(arr, 0);
  }
  

Java自带的类库

1. 查找、排序

• Arrays.sort() 快排
• Arrays.binarySearch() 二分查找

1. 比较器

• 见题目 “数组能排成的最小数”

【算法很美】递归、查找、排序 （下)相关推荐

1. 算法很美——数学问题

   算法很美--数学问题 题1:天平称重 问题描述: 用天平称重时,我们希望用尽可能少的砝码组合称出尽可能多的重量. 砝码重量分别是1,3,9,27,81--3的指数次幂,每种重量砝码只有一个 则它们可以 ...

2. 算法很美－位运算－找出落单的那个数

   上级目录:算法很美 1. 题目 一个数组里除了某一个数字之外,其他的数字都出现了两次.请写程序找出这个只出现一次的数字. 2. 异或思路 异或的运算是A ^ A＝0,也就是说偶数个相同的元素异或,结果 ...

3. ＜＜算法很美＞＞——(三)十大排序算法(下)

   目录 1. 奇数在左偶数在右 2. 最快效率求出乱序数组中第k小的数 3. 数组中有一个数字出现次数超过数组长度一半 4. 合并两个有序数组 5. 数组中的逆序对 6. 排序数组中两个数字之和 7. ...

4. 蓝桥杯：算法很美 笔记 3.查找和排序（Python实现）

   1.分治法介绍以及关键点解析 分治法(divide and conquer, D&C)∶将原问题划分成若干个规模较小而结构与原问题一致的子问题﹔递归地解决这些子问题,然后再合并其结果,就得到原 ...

5. ＜＜算法很美＞＞——(三)十大排序算法(上)

   目录 前言 冒泡排序 图解冒泡 代码实现 冒泡优化 选择排序 图解选排​ 代码实现 插入排序 图解插入 ​代码实现 希尔排序 图解希尔 ​代码实现: 归并排序 图解归并 ​代码实现 快速排序 图解快排 ...

6. 【算法很美】深入递归 （下）深度优先搜索DFS问题

   深搜.回溯.剪枝 深度优先搜索DFS 2.1 无死角搜索I 数独游戏 部分和 水洼数目 2.2 回溯和剪枝 n皇后问题 素数环 困难的串 小结 一些使用 2.1 无死角搜索I 数独游戏 你一定听说过& ...

7. 蓝桥杯算法很美笔记—排序实现题

   题1:小白上楼梯(递归设计) 小白正在上楼梯,楼梯有n阶台阶,小白一次可以上1阶,2阶或者3阶,实现一个方法,计算小白有多少种走完楼梯的方式. 思路: 一次可以上1阶,2阶或者3阶,则最后一步可以为上 ...

8. ＜＜算法很美＞＞——(四)——深入递归＜一＞——自上而下，自下而上

   目录 前言 上楼梯 机器人走方格 前言 接着上篇博客详解递归思想我们继续更深入地分析递归,本篇主要更加深入讲解上篇的自下而上和自上而下思想. 啥叫「自顶向下」?是从上向下延伸,都是从一个规模较大的原问 ...

9. 数据结构与算法之美笔记(三)排序

   排序 如何分析一个"排序算法"? 排序算法的执行效率 1.1 最好情况.最坏情况.平均情况时间复杂度 1.2 时间复杂度的系数.常数 .低阶 1.3 比较次数和交换(或移动)次数 ...

10. ＜＜算法很美＞＞——(七)——DFS典题(二):数独游戏

    目录 问题描述 问题分析 放码过来: 问题描述 如[图1.png],玩家需要根据9×9盘面上的已知数字,推理出所有剩余空格的数字,并满足每一 行.每一列.每一个同色九宫内的数字均含1-9,不重复. 数 ...

最新文章

1. python各种文件数据的读取
2. dxp计算机术语,《计算机DXP应用》.doc
3. 数据库中字段类型对应的C#中的数据类型
4. ESP8266/ESP32 NVS 基本操作
5. 海量数据库的查询优化及分页算法方案 1
6. 程序员面试100题之一：对称字符串的最大长度
7. 观察者模式在SAP CRM One Order回调函数中的应用
8. Arrays.hashCode（Object []）与Objects.hash（Object…）
9. 闭包的示例_用示例解释JavaScript中的闭包
10. 寄存器地址和内存地址_通俗易懂和你聊聊寄存器那些事(精美图文)
11. 如何在SQL Server Reporting Services中使用表达式来创建有效的报告
12. 怎么将PDF文件在线转换成JPG图片
13. 如何用VC 2005打开VC 2008的工程
14. Postgresql13之FETCH FIRST ROWS … WITH TIES展示打结的行
15. ECMAScript 6 入门教程
16. 基于深度学习的文本数据特征提取方法之Word2Vec
17. windows核心编程 第四章 进程
18. java unsafe park_java – Unsafe.park vs Object.wait
19. 在测量面积的时候，为了精确一点，鼠标在操作面积测量时能拖动画面吗？
20. java if(true)_使用 if(true) 和 if(false)

热门文章

1. android svg 线条动画教程,SVG技术入门：线条动画实现原理
2. ARM7开发软件安装步骤
3. xlsx格式表格汉字批量转音节，不带声调（python）
4. 「网站收录查询」百度收录批量查询工具主要有哪些?
5. Elasticsearch-7(全文搜索应用分享)
6. m227fdw恢复出厂设置_惠普M227fdw说明书
7. 【BZOJ 1433】 [ZJOI2009]假期的宿舍
8. 每周学一点Egret（17）default.thm.json 文件编译小坑
9. ng-zorro里的“Descriptions描述列表”使用
10. 苹果cms大橙子和B站模板教程