笔试口试假如涉及到数据结构和算法之类的题，貌似都比较喜好问二叉树，排序算法等，所以整顿一下用js写的排序算法
排序算法几个症结点就是时候复杂度、空间复杂度、稳固性，前二者关于数学渣渣的我来讲只能尽量记下来了，剖断稳固性主如果看两个雷同的元素在排序后和排序前的递次是不是转变，假如转变了就是不稳固
冒泡排序
比较相邻的元素，假如第一个数比第二个数大，就交流他们两个，从最先第一对到末端的末了一对，如许每一轮比较完毕都将会把最大的数排在末了，再反复从第一对最先比较，直到某一轮比较完毕后没有举行交流，则排序完毕
时候复杂度：O(n^n)
空间复杂度：O(1)
稳固性：稳固
JavaScript言语完成
function bubbleSort(arr){
var len = arr.length,k=0;
for(var i=0;;i++){
k=0;
for(var j=0;j<len-i-1;j++){
if(arr[j] > arr[j+1]){
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
k=1;
}
}
if(k == 0) break;
}
console.log(arr);
}挑选排序
从一组数中选出最小的与第一个数据交流，再从盈余数据中继承选出最小的与第二个数据交流
时候复杂度：O(n^n)
空间复杂度：O(1)
稳固性：不稳固
JavaScript言语完成
function selectSort(arr){
var len = arr.length;
for(var i=0;i<len;i++){
var index = i;
for(var j=i+1;j<len;j++){
if(arr[j] < arr[index]){index = j;}
}
if(index != i){
var temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
console.log(arr);
}插进去排序
将数据分为有序和无序，初始有序数据为第一个数，无序数据为盈余的，将无序数据轮回插进去到有序数据中
时候复杂度：O(n^n)
空间复杂度：O(1)
稳固性：稳固
JavaScript言语完成
function insertSort(arr){
var len = arr.length;
for(var i=1;i<len;i++){
var temp = arr[i],j=i-1;
while(j>=0 && arr[j]>temp){
arr[j+1] = arr[j];
j--;
}
arr[j+1] = temp;
}
console.log(arr);
}疾速排序
先拔取数组中一个数作为基数，将其他数据与该基数比较，假如大于基数就排在基数的右边，假如小于就排在基数的左边，再分别对小于基数和大于基数的数组做疾速排序
时候复杂度：O(nlogn)
空间复杂度：O(1ogn)
稳固性：不稳固
JavaScript言语完成
function quickSort(arr,start,end){
if(start < end){
var base = arr[start];
var temp;
var i=start,j=end;
do{
while(arr[i] < base && i < end){
i++;
}
while(arr[j] > base && j > start){
j--;
}
if(i <= j){
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}while(i <= j);
if(start < j){
sort4(arr,start,j);
}
if(end > i){
sort4(arr,i,end);
}
}
console.log(arr);
}合并排序
先将一切数据两两分组举行排序，再两两合并，反复举行直到一切数据合并成一个有序表
时候复杂度：O(nlogn)
空间复杂度：O(1)
稳固性：稳固
JavaScript言语完成
function mergeSort(arr){
function sort(array,first,last){
first = (first === undefined) ? 0 : first;
last = (last === undefined) ? array.length-1 : last;
if(last - first <１){return;}
sort(arr,first,middle);
sort(arr,middle+1,last);
var f=first,
m=middle,
i,
temp;
while(f <= m && m + 1 <= last){
if(arr[f] >= arr[m+1]){
temp = arr[m+1];
for(i=m;i>=f;i--){
arr[i+1]=arr[i];
}
arr[f] = temp;
m++;
}else {
f++;
}
}
return arr;
}
return sort(arr);
}堆排序
将数据示意成完整二叉树的情势，而且以最大堆的体式格局排序，再一次交流末了一个末了一个元素和根元素，而且每一次都从新举行最大堆排序
时候复杂度：O(nlogn)
空间复杂度：O(1)
稳固性：不稳固
JavaScript言语完成
function heapSort(array){
function swap(array,i,j){
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
/*最大堆调解*/
function maxHeapify(array,index,heapSize){
var iMax,
iLeft,
iRight;
while(true){
iMax = index;
iLeft = 2 * index + 1;
iRight = 2 * (index + 1);
if(iLeft < heapSize && array[index] < array[iLeft]){
iMax = iLeft;
}
if(iRight < heapSize && array[iMax] < array[iRight]){
iMax = iRight;
}
if(iMax != index){
swap(array,iMax,index);
index = iMax;
}else{break;}
}
}
/*建立最大堆*/
function buildMaxHeap(array){
var i,
iParent = Math.floor(array.length/2) - 1;
for(i = iParent; i >= 0; i--){
maxHeapify(array,i,array.length);
}
}
/*堆排序*/
function sort(array){
buildMaxHeap(array);
for(var i = array.length - 1;i > 0; i--){
swap(array, 0, i);
maxHeapify(array, 0, i);
}
return array;
}
return sort(array);希尔排序
每次对相隔肯定距离的数举行插进去排序
时候复杂度：O(nlogn)
空间复杂度：O(1)
稳固性：不稳固
JavaScript言语完成
function shellSort(array){
function swap(array, i, k){
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
var length = array.length,
gap = Math.floor(length / 2);
while(gap > 0){
for(var i = gap; i < length; i++){
for(var j = i; j > 0; j -= gap){
if(array[j - gap] > array[j]){
swap(array, j - gap, j);
}else {
break;
}
}
}
gap = Math.floor(gap/2);
}
return array;
}