javascript中的常用算法

1.冒泡排序

冒泡排序比较任意两个相邻的项，如果第一个比第二个大，则交换他们

function BubbleSort(array){
   var length = array.length;
   for (var i = 0; i < length;i++) {
       for(var j = 0; j < length-i-1; j++){
          if(array[j]>array[j+1]) {
              [array[j], array[j+1]] = [array[j+1], array[j]];
          }
       }
   }
}

2.选择排序

选择排序是找到数据结构中的最小值，并把他放在第一位，接着找到第二小的值并把他放在第二位，以此类推

function selection(array) {
    var length = array.length;
    var minIndex;
    for(var i = 0; i < length-1; i++) {
        minIndex = i;
        for(var j = i; j < length; j++) {
           if(array[minIndex] > array[j]) {
               minIndex = j;
           }
        }
        if(i!=minIndex) {
           [i, minIndex] = [minIndex, i];
        }
    }
}

3.插入排序

插入排序每次排一个数组项，以此方式构建最后的排序数组

function insertSort(array) {
   var length = array.length;
   var j,temp;
   for (var i = 1; i < length; i++) {
      j = i;
      temp = array[i];
      while (j > 0 && array[j-1] > temp) {
         array[j] = array[j-1];
         j--;
      }
      array[j] = temp;
   }
}

4.快速排序

1. 从数组中选择中间一项作为主元。
2. 创建两个指针，左边一个指向数组第一个项，右边一个指向数组最后一个项。移动左指针直到我们找到一个比主元大的元素，接着，移动右指针直到找到一个比主元小的元素，然后交换他们，重复这个过程，直到左指针超过了右指针。这个过程将使得比主元小的值都排在主元之前，而比主元大的值都排在主元之后。
3. 接着，算法对划分后的小数组（较主元小的值组成的子数组，以及较主元大的值组成的子数组）重复之前的两个步骤，直到数组完全排序。

function quickSort(array, left, right) {
    var index;
    if(array.length > 1) {
       index = partition(array, left, right);
       if(left < index-1) {
          quickSort(array, left, index-1);
       }
       if(index < right) {
          quickSort(array, index, right);
      }
    }
}

function partition(array, left, right) {
   /* 选择主元 */
   var pivot = array[Math,floor(left + right)/2];
   var i = left, j = right;
   while(i < j) {
     while(array[i] < array[pivot]) {
        i++;
     }
     while(array[j] > array[pivot]) {
        j--;
     }
     if(i <= j) {
        [array[i], array[j]] = [array[j], array[i]];
         i++;
         j--;
     }
   }
   return i;
}

5.堆排序

1. 构造一个满足array[parent(i)] ≥ array[i]的堆结构。
2. 交换堆里第一个元素（数组中较大的值）和最后一个元素的位置。
3. 第二步可能会丢失堆的属性，因此需再次将数组转换成堆，也就是找到当前堆的根节点（较小的值）重新放到树的底部。

function heapSort(array) {
    var heapSize = array.length;
    buildHeap(array);
    while(heapSize > 1) {
        heapSize--;
        [array[0], array[heapSize]] = [array[heapSize], array[0]];
        heapify(array, heapSize, 0);
    }
}

function buildHeap(array) {
   var heapSize = array.length;
   for(var i = Math.floor(heapSize/2; i >= 0; i--)) {
       heapify(array, heapSize, i);
    }
}

function heapify(array, heapSize, i){
   var left = i * 2 + 1,
       right = i * 2 + 2,
       largest = i;
   if(left < heapSize && array[left] > array[largest]) {
       largest = left;
    }
   if(right < heapSize && array[right] > array[largest]) {
      largest = right;
   }
   if(largest != i) {
      [array[i], array[largest]] = [array[largest], array[i]];
      heapify(array, heapSize, largest);
   }
}