diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md
index 153a88f7..f202080e 100644
--- a/notes/剑指 offer 题解.md	
+++ b/notes/剑指 offer 题解.md	
@@ -783,7 +783,7 @@ public double Power(double base, int exponent) {
 
 ## 解题思路
 
-由于 n 可能会非常大，因此不能直接用 int 存储数，而是用 char 数组进行存储。
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
 
 使用回溯法得到所有的数。
 
@@ -794,41 +794,31 @@ public void print1ToMaxOfNDigits(int n) {
     print1ToMaxOfNDigits(number, -1);
 }
 
-private void print1ToMaxOfNDigits(char[] number, int idx) {
-    if (idx == number.length - 1) {
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+    if (digit == number.length - 1) {
         printNumber(number);
         return;
     }
     for (int i = 0; i < 10; i++) {
-        number[idx + 1] = (char) (i + '0');
-        print1ToMaxOfNDigits(number, idx + 1);
+        number[digit + 1] = (char) (i + '0');
+        print1ToMaxOfNDigits(number, digit + 1);
     }
 }
-
-private void printNumber(char[] number) {
-    boolean isBeginWith0 = true;
-    for (char c : number) {
-        if (isBeginWith0 && c != '0') isBeginWith0 = false;
-        if(!isBeginWith0) System.out.print(c);
-    }
-    System.out.println();
-}
 ```
 
 # 18.1 在 O(1) 时间内删除链表节点
 
 ## 解题思路
 
-① 如果链表不是尾节点，那么可以直接将下一个节点的值赋给节点，令节点指向下下个节点，然后删除下一个节点，时间复杂度为 O(1)。
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，令该节点指向下下个节点，然后删除下一个节点，时间复杂度为 O(1)。
 
 <div align="center"> <img src="../pics//72f9bc11-06a9-40b4-8939-14f72e5cb4c3.png"/> </div><br>
 
-
-② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向节点的下一个节点，时间复杂度为 O(N)。
+② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
 
 <div align="center"> <img src="../pics//2a398239-ee47-4ea1-b2d8-0ced638839ef.png"/> </div><br>
 
-③ 综上，如果进行 N 次操作，那么大约需要移动节点的次数为 N-1+N=2N-1，其中 N-1 表示不是链表尾节点情况下的移动次数，N 表示是尾节点情况下的移动次数。(2N-1)/N \~ 2，因此该算法的时间复杂度为 O(1)。
+综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个为节点以 O(n) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
 
 ```java
 public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
@@ -858,21 +848,17 @@ Output : 1->2->5
 
 ## 解题描述
 
-
 ```java
 public ListNode deleteDuplication(ListNode pHead) {
     if (pHead == null) return null;
-    if (pHead.next == null) return pHead;
-    if (pHead.val == pHead.next.val) {
-        ListNode next = pHead.next;
-        while (next != null && pHead.val == next.val) {
-            next = next.next;
-        }
+    ListNode next = pHead.next;
+    if (next == null) return pHead;
+    if (pHead.val == next.val) {
+        while (next != null && pHead.val == next.val) next = next.next;
         return deleteDuplication(next);
-    } else {
-        pHead.next = deleteDuplication(pHead.next);
-        return pHead;
     }
+    pHead.next = deleteDuplication(pHead.next);
+    return pHead;
 }
 ```
 
diff --git a/notes/面向对象思想.md b/notes/面向对象思想.md
index 1a5dbf80..b4e5f032 100644
--- a/notes/面向对象思想.md
+++ b/notes/面向对象思想.md
@@ -1,19 +1,19 @@
 <!-- GFM-TOC -->
-* [第一章 设计原则](#第一章-设计原则)
+* [一、设计原则](#一设计原则)
     * [S.O.L.I.D](#solid)
     * [其他常见原则](#其他常见原则)
-* [第二章 三大特性](#第二章-三大特性)
+* [二、三大特性](#二三大特性)
     * [封装](#封装)
     * [继承](#继承)
     * [多态](#多态)
-* [第三章 UML](#第三章-uml)
+* [三、UML](#三uml)
     * [类图](#类图)
     * [时序图](#时序图)
 * [参考资料](#参考资料)
 <!-- GFM-TOC -->
 
 
-# 第一章 设计原则
+# 一、设计原则
 
 设计原则可以帮助我们避免那些糟糕的设计。
 
@@ -102,7 +102,7 @@
 
 包之间的依赖关系都应该是稳定方向依赖的，包要依赖的包要比自己更具有稳定性。
 
-# 第二章 三大特性
+# 二、三大特性
 
 ## 封装
 
@@ -197,7 +197,7 @@ public class Music {
 }
 ```
 
-# 第三章 UML
+# 三、UML
 
 ## 类图