算法篇
1、快速排序（Quick Sort）
快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高! 它是处理大数据最快的排序算法之一了。
(1)算法简介
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
(2)算法描述和实现
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- <1>.从数列中挑出一个元素，称为 "基准"（pivot）；
- <2>.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- <3>.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
Javascript代码实现：
/*方法说明：快速排序
@param array 待排序数组*/
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
var quickSort=function(arr){
if(arr.length <= 1){
return arr;
}
var keyIndex=Math.floor(arr.length / 2);
var key=arr.splice(keyIndex,1)[0];
var left=[];
var right=[];
for(var i=0;i<arr.length;i++){
if(arr[i] < index){
left.push(arr[i]);
}else {
right.push(arr[i]);
}
}
return quickSort(left).concat([index],quickSort(right);
}
快速排序动图演示：
(3)算法分析
- 最佳情况：T(n) = O(nlogn)
- 最差情况：T(n) = O(n2)
- 平均情况：T(n) = O(nlogn)
2、冒泡排序（Bubble Sort）
(1)算法描述
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
(2)算法描述和实现
具体算法描述如下：
-
<1>.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
-
<2>.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
-
<3>.针对所有的元素重复以上的步骤，除了最后一个；
-
<4>.重复步骤1~3，直到排序完成。
JavaScript代码实现：
传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的 方法一次可以得到两个最终值(最大者和最小者) ,从而使排序趟数几乎减少了一半。
function bubbleSort3(arr3) {
var low = 0;
var high= arr.length-1; //设置变量的初始值
var tmp,j;
while (low < high) {
for (j= low; j< high; ++j) //正向冒泡,找到最大者
if (arr[j]> arr[j+1]) {
tmp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=tmp;
}
--high; //修改high值, 前移一位
for (j=high; j>low; --j) //反向冒泡,找到最小者
if (arr[j]
冒泡排序动图演示:
(3)算法分析
- 最佳情况：T(n) = O(n)
当输入的数据已经是正序时（都已经是正序了，为毛何必还排序呢....）
- 最差情况：T(n) = O(n2)
当输入的数据是反序时(卧槽，我直接反序不就完了....)
- 平均情况：T(n) = O(n2)
3、选择排序（Selection Sort）
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n²)的时间复杂度.....所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
(1)算法简介
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
(2)算法描述和实现
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
-
<1>.初始状态：无序区为R[1..n]，有序区为空；
-
<2>.第i趟排序(i=1,2,3...n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
-
<3>.n-1趟结束，数组有序化了。
Javascript代码实现:
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;
}
console.timeEnd('选择排序耗时');
return arr;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(selectionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
选择排序动图演示：
(3)算法分析
- 最佳情况：T(n) = O(n2)
- 最差情况：T(n) = O(n2)
- 平均情况：T(n) = O(n2)
4、插入排序（Insertion Sort）
(1)算法简介
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
(2)算法描述和实现
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
-
<1>.从第一个元素开始，该元素可以认为已经被排序；
-
<2>.取出下一个元素，在已经排序的元素序列中从后向前扫描；
-
<3>.如果该元素（已排序）大于新元素，将该元素移到下一位置；
-
<4>.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
-
<5>.将新元素插入到该位置后；
-
<6>.重复步骤2~5。
Javascript代码实现:
function insertionSort(array) {
if (Object.prototype.toString.call(array).slice(8, -1) === 'Array') {
console.time('插入排序耗时：');
for (var i = 1; i < array.length; i++) {
var key = array[i];
var j = i - 1;
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j--;
}
array[j + 1] = key;
}
console.timeEnd('插入排序耗时：');
return array;
} else {
return 'array is not an Array!';
}
}
插入排序动图演示:
(3)算法分析
- 最佳情况：输入数组按升序排列。T(n) = O(n)
- 最坏情况：输入数组按降序排列。T(n) = O(n2)
- 平均情况：T(n) = O(n2)
5、希尔排序（Shell Sort）
(1)算法描述和实现
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
-
<1>. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
-
<2>.按增量序列个数k，对序列进行k 趟排序；
-
<3>.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
Javascript代码实现：
function shellSort(arr) {
var len = arr.length,
temp,
gap = 1;
console.time('希尔排序耗时:');
while(gap < len/5) { //动态定义间隔序列
gap =gap*5+1;
}
for (gap; gap > 0; gap = Math.floor(gap/5)) {
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;
}
}
console.timeEnd('希尔排序耗时:');
return arr;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(shellSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
（2）、希尔排序动态演示
假设我们有如下7个元素，分别为84, 25, 59, 71, 62, 16, 34，现在进行希尔排序。
第一轮选取所有元素数量的一半作为增量，即7/2，取3，所以第一轮增量为3，那么第一组分组就是索引为0,3,6对应的元素，即84,71,34，对其进行插入排序操作，
把84当做已排序序列，接着准备将组内第二个元素71插入到已排序序列中，
71小于84，所以84后移到71原来的位置，
接着将组内第三个元素34插入到已排序序列中，首先与84比较，
34小于84，所以84后移，然后继续与71比较，
34小于71，所以71后移，34放进去。然后开始处理第二组分组，第二组分组就是索引为1,4对应的元素，即25,62，对其进行插入排序操作，
把25当做已排序序列，接着将组内第二个元素62插入到已排序序列中，
25小于62，所以不移动。然后开始处理第三组分组，第三组分组就是索引为2,5对应的元素，即59,16，对其进行插入排序操作，
把59当做已排序序列，接着将组内第二个元素16插入到已排序序列中，
16小于59，所以59后移而16前移。至此处理完增量为3的情况。
第二轮增量为上一轮增量的二分之一，即3/2，取1，所以第二轮增量为1，此时所有元素组成同一个分组，对该组进行插入排序操作，首先将34当成已排序序列，准备将25插入到已排序序列，
25小于34，于是34后移，
继续将下一个元素插入已排序序列中，16与34比较，
16小于34，于是34右移，接着16与25比较，
16小于25,25后移，16放进对应位置，
继续将下一个元素插入已排序序列中，71与34比较，
（3）算法分析
- 最佳情况：T(n) = O(nlog2 n)
- 最坏情况：T(n) = O(nlog2 n)
- 平均情况：T(n) =O(nlog n)
6、堆排序（Heap Sort）
(1)算法简介
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
(2)算法描述和实现
具体算法描述如下：
-
首先遍历数组，判断该节点的父节点是否比他小，如果小就交换位置并继续判断，直到他的父节点比他大 重新以上操作 1，直到数组首位是最大值
-
然后将首位和末尾交换位置并将数组长度减一，表示数组末尾已是最大值，不需要再比较大小
-
对比左右节点哪个大，然后记住大的节点的索引并且和父节点对比大小，如果子节点大就交换位置
-
重复以上操作 3 - 4 直到整个数组都是大根堆。
Javascript代码实现：
function heap(array) {
checkArray(array);
// 将最大值交换到首位
for (let i = 0; i < array.length; i++) {
heapInsert(array, i);
}
let size = array.length;
// 交换首位和末尾
swap(array, 0, --size);
while (size > 0) {
heapify(array, 0, size);
swap(array, 0, --size);
}
return array;
}
function heapInsert(array, index) {
// 如果当前节点比父节点大，就交换
while (array[index] > array[parseInt((index - 1) / 2)]) {
swap(array, index, parseInt((index - 1) / 2));
// 将索引变成父节点
index = parseInt((index - 1) / 2);
}
}
function heapify(array, index, size) {
let left = index * 2 + 1;
while (left < size) {
// 判断左右节点大小
let largest =
left + 1 < size && array[left] < array[left + 1] ? left + 1 : left;
// 判断子节点和父节点大小
largest = array[index] < array[largest] ? largest : index;
if (largest === index) break;
swap(array, index, largest);
index = largest;
left = index * 2 + 1;
}
}
堆排序动图演示：
(3)算法分析
- 最佳情况：T(n) = O(nlogn)
- 最差情况：T(n) = O(nlogn)
- 平均情况：T(n) = O(nlogn)
