关于javascript:js算法

1.1 冒泡排序

比拟相邻的元素。如果第一个比第二个大，就替换他们两个

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;
            }
        }
    }
    return arr;
}

1.2 抉择排序

在未排序序列中找到最小（大）元素，寄存到排序序列的起始地位，再从残余未排序元素中持续寻找最小（大）元素，而后放到已排序序列的开端

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保留
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

1.3 插入排序

是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应地位并插入。

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

1.4 希尔排序

先将整个待排序的记录序列宰割成为若干子序列别离进行间接插入排序，待整个序列中的记录 ” 根本有序 ” 时，再对整体记录进行顺次间接插入排序

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          // 动静定义距离序列
        gap =gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {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];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

1.5 归并排序

该算法是采纳分治法的一个十分典型的利用。将已有序的子序列合并，失去齐全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

function mergeSort(arr) {  // 采纳自上而下的递归办法
    var len = arr.length;
    if(len < 2) {return arr;}
    var middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right)
{var result = [];

    while (left.length && right.length) {if (left[0] <= right[0]) {result.push(left.shift());
        } else {result.push(right.shift());
        }
    }

    while (left.length)
        result.push(left.shift());

    while (right.length)
        result.push(right.shift());

    return result;
}

1.6 疾速排序

“疾速排序（Quicksort）是对冒泡排序算法的一种改良。”

function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;

    if (left < right) {partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}

function partition(arr, left ,right) {     // 分区操作
    var pivot = left,                      // 设定基准值（pivot）index = pivot + 1;
    for (var i = index; i <= right; i++) {if (arr[i] < arr[pivot]) {swap(arr, i, index);
            index++;
        }        
    }
    swap(arr, pivot, index - 1);
    return index-1;
}

function swap(arr, i, j) {var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
function partition2(arr, low, high) {let pivot = arr[low];
  while (low < high) {while (low < high && arr[high] > pivot) {--high;}
    arr[low] = arr[high];
    while (low < high && arr[low] <= pivot) {++low;}
    arr[high] = arr[low];
  }
  arr[low] = pivot;
  return low;
}

function quickSort2(arr, low, high) {if (low < high) {let pivot = partition2(arr, low, high);
    quickSort2(arr, low, pivot - 1);
    quickSort2(arr, pivot + 1, high);
  }
  return arr;
}

1.7 堆排序

堆排序是指利用堆这种数据结构所设计的一种排序算法。沉积是一个近似齐全二叉树的构造，并同时满足沉积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序能够说是一种利用堆的概念来排序的抉择排序。

var len;    // 因为申明的多个函数都须要数据长度，所以把 len 设置成为全局变量

function buildMaxHeap(arr) {   // 建设大顶堆
    len = arr.length;
    for (var i = Math.floor(len/2); i >= 0; i--) {heapify(arr, i);
    }
}

function heapify(arr, i) {     // 堆调整
    var left = 2 * i + 1,
        right = 2 * i + 2,
        largest = i;

    if (left < len && arr[left] > arr[largest]) {largest = left;}

    if (right < len && arr[right] > arr[largest]) {largest = right;}

    if (largest != i) {swap(arr, i, largest);
        heapify(arr, largest);
    }
}

function swap(arr, i, j) {var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

function heapSort(arr) {buildMaxHeap(arr);

    for (var i = arr.length-1; i > 0; i--) {swap(arr, 0, i);
        len--;
        heapify(arr, 0);
    }
    return arr;
}

1.8 计数排序

计数排序的外围在于将输出的数据值转化为键存储在额定开拓的数组空间中。作为一种线性工夫复杂度的排序，计数排序要求输出的数据必须是有确定范畴的整数。

function countingSort(arr, maxValue) {var bucket = new Array(maxValue+1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;

    for (var i = 0; i < arrLen; i++) {if (!bucket[arr[i]]) {bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }

    for (var j = 0; j < bucketLen; j++) {while(bucket[j] > 0) {arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }

    return arr;
}

1.9 桶排序

是将数组分到无限数量的桶子里。每个桶子再个别排序（有可能再应用别的排序算法或是以递归形式持续应用桶排序进行排序）。桶排序是鸽巢排序的一种演绎后果。当要被排序的数组内的数值是平均调配的时候，桶排序应用线性工夫（Θ（n））。但桶排序并不是 比拟排序，他不受到 O(n log n) 上限的影响。

function bucketSort(arr, bucketSize) {if (arr.length === 0) {return arr;}

    var i;
    var minValue = arr[0];
    var maxValue = arr[0];
    for (i = 1; i < arr.length; i++) {if (arr[i] < minValue) {minValue = arr[i];                // 输出数据的最小值
      } else if (arr[i] > maxValue) {maxValue = arr[i];                // 输出数据的最大值
      }
    }

    // 桶的初始化
    var DEFAULT_BUCKET_SIZE = 5;            // 设置桶的默认数量为 5
    bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
    var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;  
    var buckets = new Array(bucketCount);
    for (i = 0; i < buckets.length; i++) {buckets[i] = [];}

    // 利用映射函数将数据调配到各个桶中
    for (i = 0; i < arr.length; i++) {buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
    }

    arr.length = 0;
    for (i = 0; i < buckets.length; i++) {insertionSort(buckets[i]);                      // 对每个桶进行排序，这里应用了插入排序
        for (var j = 0; j < buckets[i].length; j++) {arr.push(buckets[i][j]);                      
        }
    }

    return arr;
}

1.10 基数排序

基数排序是一种非比拟型整数排序算法，其原理是将整数按位数切割成不同的数字，而后按每个位数别离比拟。因为整数也能够表白字符串（比方名字或日期）和特定格局的浮点数，所以基数排序也不是只能应用于整数。

//LSD Radix Sort
var counter = [];
function radixSort(arr, maxDigit) {
    var mod = 10;
    var dev = 1;
    for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {for(var j = 0; j < arr.length; j++) {var bucket = parseInt((arr[j] % mod) / dev);
            if(counter[bucket]==null) {counter[bucket] = [];}
            counter[bucket].push(arr[j]);
        }
        var pos = 0;
        for(var j = 0; j < counter.length; j++) {
            var value = null;
            if(counter[j]!=null) {while ((value = counter[j].shift()) != null) {arr[pos++] = value;
                }
          }
        }
    }
    return arr;
}