diff --git a/1.bubbleSort.md b/1.bubbleSort.md
index 78c3b83..24ade0f 100644
--- a/1.bubbleSort.md
+++ b/1.bubbleSort.md
@@ -32,16 +32,30 @@
 
 
 ## 5. JavaScript 代码实现
+```js
+function bubbleSort(arr) {
+    var len = arr.length;
+    for (var i = 0; i < len - 1; i++) {
+        for (var j = 0; j < len - 1 - i; j++) {
+            if (arr[j] > arr[j + 1]) {
+		[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+            }
+        }
+    }
+    return arr;
+}
+```
+
 
 ```js
 function bubbleSort(arr) {
     var len = arr.length;
     for (var i = 0; i < len - 1; i++) {
         for (var j = 0; j < len - 1 - i; j++) {
-            if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
-                var temp = arr[j+1];        // 元素交换
-                arr[j+1] = arr[j];
-                arr[j] = temp;
+            if (arr[j] > arr[j + 1]) {        // 相邻元素两两对比
+                arr[j] = arr[j] ^ arr[j + 1];        // 元素交换
+                arr[j] = arr[j] ^ arr[j + 1];
+                arr[j + 1] = arr[j] ^ arr[j + 1];
             }
         }
     }
diff --git a/2.selectionSort.md b/2.selectionSort.md
index 103830e..59e8775 100644
--- a/2.selectionSort.md
+++ b/2.selectionSort.md
@@ -22,7 +22,7 @@
 ```js
 function selectionSort(arr) {
     var len = arr.length;
-    var minIndex, temp;
+    var minIndex;
     for (var i = 0; i < len - 1; i++) {
         minIndex = i;
         for (var j = i + 1; j < len; j++) {
@@ -30,10 +30,11 @@ function selectionSort(arr) {
                 minIndex = j;                 // 将最小数的索引保存
             }
         }
-        temp = arr[i];
-        arr[i] = arr[minIndex];
-        arr[minIndex] = temp;
-    }
+        arr[i] = arr[i] ^ arr[minIndex];
+        arr[minIndex] = arr[i] ^ arr[minIndex];
+        arr[i] = arr[i] ^ arr[minIndex];
+	// 或者使用ES6的解构赋值
+    }
     return arr;
 }
 ```
diff --git a/3.insertionSort.md b/3.insertionSort.md
index c828cb3..002f9aa 100644
--- a/3.insertionSort.md
+++ b/3.insertionSort.md
@@ -21,16 +21,15 @@
 
 ```js
 function insertionSort(arr) {
-    var len = arr.length;
-    var preIndex, current;
-    for (var i = 1; i < len; i++) {
+    var preIndex;
+    for (var i = 1; i < arr.length; i++) {
+    	var current = arr[i];
         preIndex = i - 1;
-        current = arr[i];
-        while(preIndex >= 0 && arr[preIndex] > current) {
-            arr[preIndex+1] = arr[preIndex];
+        while(preIndex >= 0 && arr[preIndex] > arr[i]) {
+            arr[preIndex + 1] = arr[preIndex];
             preIndex--;
         }
-        arr[preIndex+1] = current;
+        arr[preIndex + 1] = current;
     }
     return arr;
 }
diff --git a/4.shellSort.md b/4.shellSort.md
index e6d5f9c..0464b76 100644
--- a/4.shellSort.md
+++ b/4.shellSort.md
@@ -9,6 +9,7 @@
 
 希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
 
+ ![希尔排序演示](https://segmentfault.com/img/bVNRxY?w=542&h=383)
 
 ## 1. 算法步骤
 
@@ -18,24 +19,27 @@
 
 3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
 
-
 ## 2. JavaScript 代码实现
 
 ```js
-function shellSort(arr) {
+/**
+ * arr:  排序数组
+ *  gapLen: 排序增量
+ **/
+function shellSort(arr, gapLen) {
     var len = arr.length,
         temp,
         gap = 1;
-    while(gap < len/3) {          //动态定义间隔序列
-        gap =gap*3+1;
+    while(gap < len / gapLen) {          //动态定义间隔序列
+        gap = gap * gapLen + 1;
     }
-    for (gap; gap > 0; gap = Math.floor(gap/3)) {
+    for (gap; gap > 0; gap = Math.floor(gap / gapLen)) {
         for (var i = gap; i < len; i++) {
             temp = arr[i];
-            for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
-                arr[j+gap] = arr[j];
+            for (var j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
+                arr[j + gap] = arr[j];
             }
-            arr[j+gap] = temp;
+            arr[j + gap] = temp;
         }
     }
     return arr;
diff --git a/6.quickSort.md b/6.quickSort.md
index 28ad477..3616cab 100644
--- a/6.quickSort.md
+++ b/6.quickSort.md
@@ -30,6 +30,24 @@
 ## 3. JavaScript 代码实现
 
 ```js
+// NO.1 Solution
+var quickSort = function(arr) {
+    if (arr.length <= 1) { return arr; }
+    var pivotIndex = Math.floor(arr.length / 2);   //基准位置（理论上可任意选取）
+    var pivot = arr.splice(pivotIndex, 1)[0];  //基准数
+    var left = [];
+    var right = [];
+    for (var i = 0; i < arr.length; i++){
+        if (arr[i] < pivot) {
+            left.push(arr[i]);
+        } else {
+            right.push(arr[i]);
+        }
+    }
+    return quickSort(left).concat([pivot], quickSort(right));  //链接左数组、基准数构成的数组、右数组
+};
+
+// NO.2 Solution
 function quickSort(arr, left, right) {
     var len = arr.length,
         partitionIndex,
@@ -79,6 +97,10 @@ function partition2(arr, low, high) {
 }
 
 function quickSort2(arr, low, high) {
+  const len = arr.length;
+  low = typeof low != 'number' ? 0 : low,
+  high = typeof high != 'number' ? len - 1 : high;
+
   if (low < high) {
     let pivot = partition2(arr, low, high);
     quickSort2(arr, low, pivot - 1);
diff --git a/README.md b/README.md
index 4c36daa..67a1f24 100644
--- a/README.md
+++ b/README.md
@@ -60,6 +60,8 @@
 
 本书内容几乎完全来源于网络。
 
+[参考地址](https://juejin.im/post/57dcd394a22b9d00610c5ec8#heading-15)
+
 开源项目地址：[https://github.com/hustcc/JS-Sorting-Algorithm](https://github.com/hustcc/JS-Sorting-Algorithm)，整理人 [hustcc](https://github.com/hustcc)。
 
 GitBook 在线阅读地址：[https://sort.hust.cc/](https://sort.hust.cc/)。