javascript 数组排序原理的简单理解

js内置的Array函数原型对象有个sort方法，这个方法能按照顺序排序数组。

例如：

 var arr1 = [6, 4, 2, 5, 2];
 arr1.sort((x, y) => x - y);
 console.log(arr1); // [2, 2, 4, 5, 6];

以升序为例，这个方法的实现原理的简单理解：

第一轮比较。

先拿第一个数和第二个数字比较，如果第一个比第二个大，则交换位置。

接着又拿第一个数和第三个数比较，如果第一个比第三个大，则交换位置。

。。。

最后拿第一个数与最后一个数比较，如果第一个数比最后一个数大，则交换位置。

以上是第一轮比较。经过第一轮的比较。第一个数，就是数组中值最小的数了。

用上述例子来描述第一轮比较的过程，如图：

接着开始第二轮比较

先拿第二个数与第三个数比较，如果第二个比第三个大，则交换位置。

然后又拿第二个数和第四个数比较，如果第二个比第四个大，则交换位置。

。。。

最后拿第二个数与最后一个数比较，如果第二个数比最后一个数大，则交换位置。

以上是第二轮比较。经过第二轮的比较。第二个数，就是数组中值的第二小的数了。

用上述例子来描述第二轮比较的过程，如图：

循环往复直至全部都比较完。

上述例子的比较过程的代码演示：

 function mySort(arr, cb) {
   window.count = 0;// 统计循环次数
   const res = cb && cb(1, 2);
   let i, j, len = arr.length;
   if (res < 0) {// 升序
     for (i = 0; i < len; i++) {
       for (j = i + 1; j < len; j++) {
         count++;
         if (arr[i] > arr[j]) {
           [arr[i], arr[j]] = [arr[j], arr[i]];
         }
       }
     }
   } else {// 降序
     for (i = 0; i < len; i++) {
       for (j = i + 1; j < len; j++) {
         count++;
         if (arr[i] < arr[j]) {
           [arr[i], arr[j]] = [arr[j], arr[i]];
         }
       }
     }
   }
 }

这种排序方法循环次数为 (len - 1) * len / 2。

验证：

 const arr = [];
 for (let i = 0; i < 10; i++) {
   arr.push(Math.floor(Math.random()*100));
 }
 mySort(arr, (x, y) => x - y);

结果：

采用排序二叉树结构的算法。代码演示：

 function mySort(arr, cb) {
   const res = cb && cb(1 ,2);
   class Node {
     constructor(key) {
       this.key = key;
       this.left = null;
       this.right = null;
     }
   };
   class BinaryTree {
     constructor(key) {
       this.root = null;
       this.init(key);
     }
     init(key) {
       this.root = new Node(key);
     }
     insert(key) {
       const newNode = new Node(key);
       this._insertNode(this.root, newNode);
     }
     _insertNode(root, node) {
       if (node.key < root.key) {
         if (!root.left) {
           root.left = node;
         } else {
           this._insertNode(root.left, node);
         }
       } else {
         if (!root.right) {
           root.right = node;
         } else {
           this._insertNode(root.right, node);
         }
       }
     }
     inorderTraversal(callback) {
       if (res < 0) {
         this._inorderTraversalNodeSmall(this.root, callback);
       } else {
         this._inorderTraversalNodeBig(this.root, callback);
       }
     }
     _inorderTraversalNodeSmall(node, callback) {
       if (!!node) {
         this._inorderTraversalNodeSmall(node.left, callback);
         callback(node);
         this._inorderTraversalNodeSmall(node.right, callback);
       }
     }
     _inorderTraversalNodeBig(node, callback) {
       if (!!node) {
         this._inorderTraversalNodeBig(node.right, callback);
         callback(node);
         this._inorderTraversalNodeBig(node.left, callback);
       }
     }
   }

   const binaryTree = new BinaryTree(arr[0]);
   let i, len;
   for(i = 1, len = arr.length; i < len; i++) {
     binaryTree.insert(arr[i]);
   }
   const _arr = [];
   binaryTree.inorderTraversal(node => {
     _arr.push(node.key);
   });
   return _arr;
 }

测试：

 const arr = [];
 for (let i = 0; i < 10; i++) {
   arr.push(Math.floor(Math.random()*100));
 }
 const newArr1 = mySort(arr, (x, y) => y - x);
 const newArr2 = mySort(arr, (x, y) => x - y);

结果：

当数组比较大的时候，后面这种算法的优势明显。

现以后面这种算法为例，测试代码：

 const arr = [];
 for (let i = 0; i < 5000000; i++) {
   arr.push(Math.floor(Math.random()*50000000));
 }
 const time = new Date().getMinutes() + ':' + new Date().getSeconds();
 mySort(arr, (x, y) => x - y);
 const nextTime = new Date().getMinutes() + ':' + new Date().getSeconds();

结果：

数组长度为5000000时，函数大概运行了6秒。

如果以第一种算法为例，5000000估计要好几分钟，这里缩减一下，设置成50000。测试代码：

 const arr = [];
 for (let i = 0; i < 50000; i++) {
   arr.push(Math.floor(Math.random()*50000000));
 }
 const time = new Date().getMinutes() + ':' + new Date().getSeconds();
 mySort(arr, (x, y) => x - y);
 const nextTime = new Date().getMinutes() + ':' + new Date().getSeconds();

结果：

数组长度为50000时，函数大概运行了10秒。

第一种算法的耗时貌似也不是平滑增加的。估计也是一条陡峭的曲线。数学知识都忘光了。以后搞明白了在来完善。

二叉树的实现原理的简单理解