最近在准备春招面试，远在美国大半个月了一直都没有接到面试电话。很是灰心难过。但是学习还是要继续，生活总是要继续，菜鸟总有一天会高飞呀！
不管怎么样，还是学习吧！
1. 冒泡排序
冒泡排序是我记得最牢的了，可能是因为它的思想最简单，重复走过要排序的序列，一次比较两个元素，如果顺序错误就把它们调整过来（升序）。一直重复工作，知道把最大的元素一步步下沉到数组的尾部
function BubbleSort(arr) {
for(var i=0;i<arr.length;i++){
for(var j=0;j<arr.length-1-i;j++){//因为每次循环都会有一个数被下沉，随着x增大下沉的元素就增加了
if(arr[j]>arr[j+1]){
let temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp
}
}
}
return arr;
}2. 选择排序
选择排序对我来说也很好理解,首先在未排序的数组中找到最小（最大）元素，存放到排序序列的起始位置，然后在从生育未排序元素中继续寻找最小（最大）的元素，然后放到已排序序列的尾部，以此类推，直到所有元素排序完毕
function quickSort(arr) {
for(var i=0;i<arr.length;i++){
for(var j=i+1;j<arr.length;j++){
if(arr[j]<arr[i]){
let temp = arr[j];
arr[j] = arr[i];
arr[i] = temp
}
}
}
return arr;
}3. 插入排序
原理是，对于未排序数据，在一排序序列中从后向前扫描，为其找到相应的位置并插入。从后向前扫描的过程中需要对元素进行向后移位操作
function insertSort(arr) {
for(var i=1;i<arr.length;i++){
var preIndex =i-1;
var current = arr[i];
while(preIndex>=0&¤t<arr[preIndex]){
arr[preIndex+1]=arr[preIndex];
preIndex--;
}
arr[preIndex+1]=current;
}
return arr;
}4. 希尔排序
据说是第一个突破O(n^2)的排序操作，可以说是简单插入排序的改进版。它与插入排序的不同在于，它会优先比较距离较远的元素。所以又叫缩小增量排序。核心在于间隔序列的设定，好的间隔序列的设定能够很大程度上的降低排序的时间复杂度。这次我采用的增量是数组长度的一半，然后依次折半。当增量减至1时候，数组被分为了一组，算法停止。
我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列
function ShellSort(arr) {
var len = arr.length;
for (var gap = Math.floor(arr.length/2); gap>0;gap=Math.floor(gap/2)){
for(var i=0;i<gap;i++){//i表示被分成了几组
var j = i;
while(j<arr.length-gap){
var k = j;
while(arr[k+gap]<arr[k]&&k>=0){
var temp = arr[k+gap];
arr[k+gap] = arr[k];
arr[k] = temp;
k=k-gap;
}
j=j+gap;
}
}
}
return arr
}5. 归并排序
我觉得归并排序在实现上就可以分为两个函数，一个负责分段，一个负责合并（因为分割后的每个子序列都是有序的，合并就是两个有序数组合并的过程）
function merge(arr) {
if(arr.length<2){
return arr;
}
var mid = Math.floor(arr.length/2);
//floor 向下取值；ceil向上取值，around 正常的四舍五入
var left = arr.slice(0,mid);
var right = arr.slice(mid);
return sort(merge(left),merge(right));
}
function sort(left,right) {
var result=[];
var i=0;var j=0;
while(i<left.length&&j<right.length){
if(left[i]<right[j]){
result.push(left[i]);
i++
}
else{
result.push(right[j]);
j++
}
}
if(i==left.length){
result=result.concat(right.slice(j));
}
if(j==right.length){
result=result.concat(left.slice(i));
}
return result;
}6. 堆排序
这篇文章讲的太好了，我就是按照它的讲解步骤理解了整个过程，将代码写出来了。
堆是具有以下性质的完全二叉树：每个节点的值都大于或者等于其左右节点的值，称为大顶堆；每个节点的值都小于或者等于其左右孩子节点的值，称为小顶堆。如下图
有几个公式比较重要：
大顶堆：arr[i]>=arr[2i+1]&&arr[i]>=arr[ai+2];
小顶堆：arr[i]<=arr[2i+1]&&arr[i]<=arr[2i+2];
第一个非叶子节点：arr.length/2-1
再简单总结下堆排序的基本思路：
a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
function HeapSort(arr) {
for(var k=Math.floor(arr.length/2)-1;k>=0;k--){
arr = HightHeap(arr,k,arr.length);
}
for(var j= arr.length-1;j>0;j--){
//重新对堆顶进行调整
var temp = arr[j];
arr[j] = arr[0];
arr[0] = temp;
//调整后进行堆调整
for(var f = Math.floor(j/2)-1;f>=0;f--)
arr = HightHeap(arr,f,j);
}
return arr
}
function HightHeap(arr,i,length) {
var current = arr[i];
if(i*2+2<length&&arr[i*2+1]<arr[i*2+2]){
if(arr[i*2+2]>arr[i]){
arr[i]= arr[i*2+2];
arr[i*2+2] =current
}
}
else {
if(arr[i*2+1]>arr[i]){
arr[i]= arr[i*2+1];
arr[i*2+1] =current
}
}
return arr
}快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序
function sort(arr,left,right) {//第一次调用的时候left=0，right=arr.length-1
var standard = arr[left];
var i=left;
var j=right;
if(left>=right)return arr;
while(i<j){
while(arr[j]>=standard&&j>i)j--;
while (arr[i]<=standard&&i<j)i++;
if(i<j){
var temp= arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
arr[left] = arr[j];
arr[j]=standard;
sort(arr,left,i-1);
sort(arr,i+1,right);
return arr;
}做个记录，希望之后能找到一个自己满意的单位吧！我好笨啊 啊 啊