js数组排序

1、插入排序（Insertion sort）

基本思想：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

时间复杂度：最好：n  最坏：O(n^2)

空间复杂度：o(1)

代码：

function insertionSort(arr) {
    for (var i = 1; i < arr.length; i++) {
        var temp = arr[i];
        var j = i - 1;
        while (j > -1 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
    return arr;
}

var arr = [10, 8, 7, 6, 5, 9, 25, 3, 4];
console.log('before: ' + arr);
insertionSort(arr);console.log(' after: ' + arr);

2、快速排序（Quicksort）基本思想：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

时间复杂度：O(n^2)

空间复杂度：最好：O(logn) 最坏：O(n)代码：

function quickSort(arr) {
    if (arr.length < 2) {
        return arr;
    }
    var midIndex = Math.floor(arr.length / 2);
    var mid = arr.splice(midIndex, 1)[0];
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] > mid) {
            right.push(arr[i]);
        } else {
            left.push(arr[i]);
        }
    }
    return quickSort(left).concat([mid], quickSort(right));
}
var arr = [10, 8, 7, 6, 5, 9, 25, 3, 4];
console.log('before: ' + arr);
console.log(' after: ' + quickSort(arr));

3、冒泡排序（Bubble Sort）

基本思想：它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

时间复杂度：最好：O(n) 最坏：O(n^2)

空间复杂度：O(1)

代码：

function bubbleSort(arr) {
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                var temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

var arr = [10, 8, 7, 6, 5, 9, 25, 3, 4];

console.log('before: ' + arr);

console.log(' after: ' + bubbleSort(arr));

 

4、归并排序（MERGE-SORT）

基本思想：是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

时间复杂度：O(nlogn)

空间复杂度：O(n)

代码：

 

function　merge(left, right){
    var　result=[];
    while(left.length>0 && right.length>0){
        if(left[0]<right[0]){
            result.push(left.shift());
        }else{
            result.push(right.shift());
        }
    }
    return　result.concat(left).concat(right);
}
function　mergeSort(items){
    if(items.length == 1){
        return　items;
    }
    var　middle = Math.floor(items.length/2),
            left = items.slice(0, middle),
            right = items.slice(middle);
    return　merge(mergeSort(left), mergeSort(right));
}

var arr = [10, 8, 7, 6, 5, 9, 25, 3, 4];

console.log('before: ' + arr);

console.log(' after: ' + mergeSort(arr));

 

5、选择排序（Selection sort）

基本思想：一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

时间复杂度：O(n^2)

空间复杂度：O(1)

代码：

function selectionSort(arr) {
    if (arr.length < 2) {
        return arr;
    }
    for (var i = 0; i < arr.length - 1; i++) {
        let minIndex = i;
        for (let j = i + 1; j < arr.length; j++) {
            minIndex = arr[j] < arr[minIndex] ? j : minIndex;
        }
        let temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}
var arr = [10, 8, 7, 6, 5, 9, 25, 3, 4];
console.log('before: ' + arr);
console.log(' after: ' + selectionSort(arr));

6、二叉排序树（Binary Sort Tree）

基本思想：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：
（1）若左子树不空，则左子树上所有节点的值均小于它的根节点的值；
（2）若右子树不空，则右子树上所有节点的值均大于它的根节点的值；
（3）左、右子树也分别为二叉排序树；
（4）没有键值相等的节点。

时间复杂度：O(n^2)

空间复杂度：O(n)

代码：

function binarySort() {
    var Node = function(key){
        this.key = key;
        this.left = null;
        this.right = null;
    }
    var root = null;
    var insertNode = function(node, newNode){
        if(newNode.key < node.key){
            if(node.left === null)
                node.left = newNode;
            else
                insertNode(node.left, newNode);
        }else{
            if(node.right === null)
                node.right = newNode;
            else
                insertNode(node.right, newNode);
        }
    }

    this.insert = function(key){
        var newNode = new Node(key);
        if(root === null)
            root = newNode;
        else
            insertNode(root, newNode);
    }
};


    var nodes = [8,3,10,1,6,14,4,7,13];
    var binaryTree = new binarySort();
    nodes.forEach(function(key){
        binaryTree.insert(key);
    });