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秒。

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

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