feat: 整合排序测速工具

Author: sl1673495

.gitignore

@@ -0,0 +1,22 @@
+.DS_Store  
+._*  
+.cache  
+.project  
+.settings  
+.tmproj  
+*.esproj  
+*.sublime-project  
+*.sublime-workspace  
+nbproject  
+thumbs.db  
+*.iml  
+
+# Folders to ignore  
+.hg  
+.svn  
+.CVS  
+.idea  
+node_modules/  
+jscoverage_lib/  
+bower_components/  
+dist/

package.json

@@ -0,0 +1,5 @@
+{
+  "devDependencies": {
+    "glob": "^7.1.6"
+  }
+}

sum-four-divisors.js

@@ -0,0 +1,74 @@
+const glob = require("glob")
+const path = require("path")
+const swap = require("./交换")
+
+function sortTest(sortFns, source, desc) {
+  console.log(desc)
+  const table = {}
+
+  if (typeof source === "function") {
+    source = source()
+  }
+
+  sortFns.forEach((fn) => {
+    const copy = source.slice()
+    const start = new Date().getTime()
+
+    fn(copy)
+
+    const end = new Date().getTime()
+    const time = end - start
+    const timeStr = `${time}ms`
+    const success = isSorted(copy, source)
+
+    table[fn.sortName] = {
+      耗时: timeStr,
+      数据长度: source.length,
+      结果: success ? "成功" : "失败",
+    }
+  })
+
+  console.table(table)
+}
+
+function getRandomArray(count) {
+  const arr = []
+  for (let i = 0; i < count; i++) {
+    arr.push(Math.floor(i * Math.random() * 10))
+  }
+
+  return arr
+}
+
+function getNearlyArray(count, swapTime) {
+  const arr = []
+  for (let i = 0; i < count; i++) {
+    arr.push(i)
+  }
+
+  for (let i = 0; i < swapTime; i++) {
+    const x = Math.floor(Math.random() * count)
+    const y = Math.floor(Math.random() * count)
+    swap(arr, x, y)
+  }
+
+  return arr
+}
+
+function isSorted(target, source) {
+  return (
+    target.toString() ===
+    source
+      .slice()
+      .sort((a, b) => a - b)
+      .toString()
+  )
+}
+
+glob("排序/*.js", (err, result) => {
+  if (err) throw err
+  const sortFunctions = result
+    .map((p) => require(path.resolve(p)))
+    .filter(Boolean)
+  sortTest(sortFunctions, () => getRandomArray(10000), "普通数组排序")
+})

工具/排序速度.js

@@ -1,27 +1,29 @@
-const swap = require("../工具/交换");
+const swap = require("../工具/交换")
 /**
  * 冒泡排序
  * @param {number[]} arr
  */
 function bubbleSort(arr) {
-  let n = arr.length;
-  if (n <= 1) return arr;
+  let n = arr.length
+  if (n <= 1) return arr
 
   for (let i = 0; i < n; i++) {
-    let flag = false;
+    let flag = false
     // 从前往后冒泡 所以已经处理过的就不用再访问了
     // 并且由于每次遍历会访问j+1项，等于提前遍历了后一项
     // 所以这里的终止条件可以是n - i再减去1
     for (let j = 0; j < n - 1 - i; j++) {
       if (arr[j] > arr[j + 1]) {
-        swap(arr, j, j + 1);
-        flag = true;
+        swap(arr, j, j + 1)
+        flag = true
       }
     }
     // 如果这次循环都没有数字被交换 说明已经是排序好的数组
-    if (!flag) return arr;
+    if (!flag) return arr
   }
-  return arr;
+  return arr
 }
 
-console.log(bubbleSort([4, 5, 2, 3, 1, 6, 5, 15, 2]));
+bubbleSort.sortName = "冒泡排序"
+
+module.exports = bubbleSort

排序/冒泡排序.js

@@ -1,12 +1,12 @@
-const swap = require("../工具/交换");
+const swap = require("../工具/交换")
 
 /**
  *
  * @param {number[]} arr
  */
 function quickSort(arr) {
-  _quickSort(arr, 0, arr.length - 1);
-  return arr;
+  _quickSort(arr, 0, arr.length - 1)
+  return arr
 }
 
 /**
@@ -17,11 +17,11 @@ function quickSort(arr) {
  */
 function _quickSort(arr, l, r) {
   if (l >= r) {
-    return;
+    return
   }
-  let p = partition(arr, l, r);
-  _quickSort(arr, l, p - 1);
-  _quickSort(arr, p + 1, r);
+  let p = partition(arr, l, r)
+  _quickSort(arr, l, p - 1)
+  _quickSort(arr, p + 1, r)
 }
 
 /**
@@ -31,24 +31,26 @@ function _quickSort(arr, l, r) {
  * @param {number} r 右边界
  * @returns {number} 返回索引值p，使得arr[l...p-1] < arr[p] < arr[p+1...r]
  */
-function partition(arr, l, r) {
+function partition(arr, left, right) {
   // 取一个基准值 取第一项
-  let v = arr[l];
+  let pivot = arr[left]
 
-  // arr[l+1...j] < v < arr[j+1...i) > v
-  let j = l;
-  for (let i = l + 1; i <= r; i++) {
+  // arr[left+1...index] < pivot, arr[index+1...i) > pivot
+  let index = left
+  for (let i = left + 1; i <= right; i++) {
     let num = arr[i]
-    if (num < v) {
-      // 如果当前值小于基准值的话，就交换到j + 1后的位置去。
-      // 扩充了j的范围 [j...], v, [...r]
-      swap(arr, j + 1, i);
-      j++;
+    if (num < pivot) {
+      // 如果当前值小于基准值的话，就交换到index + 1的位置去。
+      // 扩充了index的范围 [index...], pivot, [...right]
+      swap(arr, index + 1, i)
+      index++
     }
   }
 
-  swap(arr, l, j);
-  return j
+  swap(arr, left, index)
+  return index
 }
 
-console.log(quickSort([1, 4, 2, 5, 3]));
+quickSort.sortName = "快速排序"
+
+module.exports = quickSort

排序/快速排序.js

@@ -1,16 +1,18 @@
-const swap = require("../工具/交换");
+const swap = require("../工具/交换")
 
 function selectSort(arr) {
   for (let i = 0; i < arr.length; i++) {
-    let min = i;
+    let min = i
     for (let j = i + 1; j < arr.length; j++) {
       if (arr[j] < arr[min]) {
-        min = j;
+        min = j
       }
     }
-    swap(arr, i, min);
+    swap(arr, i, min)
   }
-  return arr;
+  return arr
 }
 
-console.log(selectSort([1, 4, 3, 2, 5, 6]));
+selectSort.sortName = "选择排序"
+
+module.exports = selectSort