diff --git a/Code/Code/head/sort.h b/Code/Code/head/sort.h
index 337d904..f64a570 100644
--- a/Code/Code/head/sort.h
+++ b/Code/Code/head/sort.h
@@ -63,4 +63,22 @@ bool ShellSort(LinearTable table) {
         }
     }
     return true;
+}
+
+// ðÅÝÅÅÐò
+bool BubbleSort(LinearTable table){
+    elem_type temp;
+    // ÍâÑ­»·ÎªÅÅÐòÌËÊý£¬Ò»¹²ÐèÒªlength-1ÌË
+    for(int i=0;i<table.length-1;i++){
+        // ÄÚÑ­»·ÎªÅÅÐòÌËÊý£¬iÌ˱ȽϴÎÊýΪlength-i
+        // ÅÅÐòÍê³ÉµÄÐòÁÐÔÚºóÃæ
+        for(int j=0;j<table.length-1-i;j++){
+            if(table.data[j]>table.data[j+1]){
+                temp = table.data[j];
+                table.data[j] = table.data[j+1];
+                table.data[j+1] = temp;
+            }
+        }
+    }
+    return true;
 }
\ No newline at end of file
diff --git a/Data-Structrue/10-sort-ex.md b/Data-Structrue/10-sort-ex.md
index eb10dfc..0b256fd 100644
--- a/Data-Structrue/10-sort-ex.md
+++ b/Data-Structrue/10-sort-ex.md
@@ -15,3 +15,15 @@ $D.6$
 解：$A$。对于任��列进行基于比较的排�，求最少的比较次数应考虑最�情况。对任�$n$个关键字排�的比较次数至少$\lceil\log_2(n!)\rceil$。将$n=7$代入公�，答案为$13$。上述公��明如下（仅供有兴趣的�学�考）：在基于比较的排�方法中，�次比较两个关键字�，仅出现两��能的转移。�设整个排�过程至少需��$t$次比较，则显然会有$2^t$�情况。由于$n$个记录共有$n!$���的排列，因而必须有$n!$���的比较路径，于是有$2^t\geqslant n!$，�$t\geqslant\log_2(n!)$。考虑到$t$为整数，故为$\lceil\log_2(n!)\rceil$。
 
 ## �入排�
+
+**例题** 有些排�算法在�趟排�过程中，都会有一个元素被放置到其最终�置上，()算法�会出现此�情况。
+
+$A.$希尔排�
+
+$B.$堆排�
+
+$C.$冒泡排�
+
+$D.$快速排�
+
+解：$A$。希尔排�是组间有�组内无�。
diff --git a/Data-Structrue/10-sort.md b/Data-Structrue/10-sort.md
index 70c5142..767f693 100644
--- a/Data-Structrue/10-sort.md
+++ b/Data-Structrue/10-sort.md
@@ -63,7 +63,7 @@
 
 希尔排�也是对直接�入排�的优化。直接�入排�对于基本有�的�列排�效果较好，所以就希望�列能尽�能基本有�。从而希尔排�的�想就是先追求表中元素部分有�，然���逼近全局有�。
 
-先将整个待排�元素�列分割�若干个��列（由相隔�个“增��的元素组�的），分别进行直接�入排�（或者折��入排�），然�缩�增���上述过程，直到增�为$1$。�次对比�对比两个元素进行�入交�。
+先将整个待排�元素�列分割�若干个��列（由相隔�个“增��的元素组�的），分别进行直接�入排�，然�缩�增���上述过程，直到增�为$1$。�次对比�对比两个以上的个元素进行�入交�。
 
 增��列的选择建议是第一趟选择元素个数的一�，���断缩�到原�的一�。
 
@@ -85,13 +85,15 @@
 
 #### 冒泡排�的过程
 
-从�往�或从�往�两两比较相邻元素的值，若逆�则交�这两个值，如果相等也�交�，直到�列比较完。这个过程是一趟冒泡排�，第$i$趟�第i个元素会已�排�完�。�一趟都会让关键字最�或最大的一个元素到未排�队列的第一个或最�一个。一共需�$n-1$趟排�。
+从�往�或从�往�两两比较相邻元素的值，若逆�则交�这两个值，如果相等也�交�，直到�列比较完。这个过程是一趟冒泡排�，第$i$趟�第$i$个元素会已�排�完�。�一趟都会让关键字最�或最大的一个元素到未排�队列的第一个或最�一个。一共需�$n-1$趟排�。
+
+冒泡排�中所产生的有���列一定是全局有�的（��于直接�入排�），也就是说，有���列中的所有元素的关键字一定�于或大于无���列中所有元素的关键字，这样�趟排�都会将一个元素放置到其最终的�置上。
 
 #### 冒泡排�的性能
 
 空间��度为$O(1)$。
 
-最好情况下�本身�列有�，则比较次数是n-1，交�次数是0，从而时间��度是$O(n)$。
+最好情况下�本身�列有�，则比较次数是$n-1$，交�次数是$0$，从而时间��度是$O(n)$。
 
 最�情况是逆�情况，比较次数和交�次数都是$\dfrac{n(n-1)}{2}$，所以时间��度是$O(n^2)$。
 
@@ -103,22 +105,22 @@
 
 ### 快速排�
 
-快速排�在内部排�中的表现确实是最好的。排�过程类似于构建二�排�树。
+快速排�在内部排�中的表现确实是最好的。排�过程类似于构建二�排�树。基于分治法。
 
 #### 快速排�的过程
 
-�待排��列中的�个元素pivot作为基准（一般�第一个元素），通过一趟排�，将待排元素分为左�两个��列，左��列元素的关键字��于或等于基准元素的关键字，���列的关键字则大于基准元素的关键字，然�分别对两个��列继续进行排�，直至整个�列有�。
+�待排��列中的�个元素$pivot$作为基准（一般�第一个元素），通过一趟排�，将待排元素分为左�两个��列，左��列元素的关键字��于或等于基准元素的关键字，���列的关键字则大于基准元素的关键字，称进行了一趟快速排�（一次划分），然�分别对两个��列继续进行排�，直至整个�列有�。
 
-1. 先选择个值�标�，把标�放入pivot，比标��的放左边，大的放�边。
-2. �始时，令high指��列最�边的值，low指��列最左边的值。
-3. 然�从high开始，当�到比标�大的值时high--。
-4. 当�到比标��的值，就�出这个值放入当�low所指的�置。
-5. 然�high�动，low++开始移动。
-6. 若low所指�的值比标��，low++。
-7. 若low所指�的值比标�大，则放入当�high所指�的�置。
-8. 然�low�动，high--开始移动。回到步骤三开始执行。
-9. 当low=high时表示low和high之�的元素都比基准�，low和high之�的元素都比基准大，完�了一次划分。然�把基准元素放入low和high指�的�置。
-10. �断交替使用low和high指针进行对比。对左���列进行�样的递归�作��，从步骤三开始。若左�两个��列的元素数�等于一，则无需�划分。
+1. 先选择个值�标�，把标�放入$pivot$，比标��的放左边，大的放�边。
+2. �始时，令$high$指��列最�边的值，$low$指��列最左边的值。
+3. 然�从$high$开始，当�到比标�大的值时$high--$。
+4. 当�到比标��的值，就�出这个值放入当�$low$所指的�置。
+5. 然�$high$�动，$low++$开始移动。
+6. 若$low$所指�的值比标��，$low++$。
+7. 若$low$所指�的值比标�大，则放入当�$high$所指�的�置。
+8. 然�$low$�动，$high--$开始移动。回到步骤三开始执行。
+9. 当$low=high$时表示$low$和$high$之�的元素都比基准�，$low$和$high$之�的元素都比基准大，完�了一次划分。然�把基准元素放入$low$和$high$指�的�置。
+10. �断交替使用$low$和$high$指针进行对比。对左���列进行�样的递归�作��，从步骤三开始。若左�两个��列的元素数�等于一，则无需�划分。
 
 #### 快速排�的性能