冒泡排序
比较两个相邻的元素,将值大的元素交换到右边,需要n-1趟排序,每趟需要n-i次,这种方式通过多次迭代数组来完成操作,不管是平均还是最坏的情况,都是具有二次时间复杂度。尽管这个方式简单,但是在实际应用中,大多数情况下不切实际的:时间复杂度过高。
function bubbleSort(arr) {
for(var i=0;i<arr.length-1;i++){
for(var j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
let tem = arr[j+1];
arr[j+1] = arr[j];
arr[j] = tem;
}
}
}
return arr;
}
选择排序
选择排序是一种简单直观的排序算法,无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候,数据规模越小越好。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置。再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。重复第二步,直到所有元素均排序完毕。
function selectionSort(arr) {
for(var i=0;i<arr.length-1;i++){
var minindex=i;
for(var j=i+1;j<arr.length;j++){
if(arr[j]<arr[minindex]){
minindex = j;
}
}
var temp = arr[i];
arr[i] = arr[minindex];
arr[minindex] = temp;
}
return arr;
}
插入排序
将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)
function insertionSort(arr) {
for(var i=1;i<arr.length;i++){
var preindex = i-1;
var current = arr[i];
while(preindex>=0 && current<arr[preindex]){
arr[preindex+1] = arr[preindex];
preindex--;
}
arr[preindex+1] = current;
}
return arr;
}
归并排序
递归的将输入数组拆分成两个子数组,直到所有的子数组都只包含一个元素。将每一个排序后的子数组合并到一个数组里面,最后返回一个排序的数组。合并的时候,从长度为1的数组向上合并,合并的时候数组在排序,而快速排序是拆分的时候在排序
function mergeSort(arr){
var len = arr.length;
if(len<2){ //最终要把arr变成长度为1或0的数列
return arr;
}
var middle = Math.floor(len/2);
var left = arr.slice(0,middle);
var 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());
}
}
快速排序
选择一个基准,比基准大的放在左边数组,大的放在右边数组,不断递归至数组只有一个元素。
function quickSort(arr){
var len = arr.length;
if(len<2){
return arr;
}
var pivotIndex = Math.floor(len/2);
var pivot = arr[pivotIndex];
var left=[],right=[];
for(var i=0;i<len;i++){
if(i===pivotIndex){
continue;
}
if(arr[i]<pivot){
left.push(arr[i]);
}
else{
right.push(arr[i]);
}
}
return quickSort(left).concat([pivot],quickSort(right));
}
function swap(array,a,b){
[array[a],array[b]] = [array[b],array[a]];
}
//冒泡排序
function bubbleSort(array){
let len = array.length;
for (let i = 0; i < len; i++){
for(let i=0; i < len-1-i; i++){
if(array[i]>array[i+1]){
swap(array,i,i+1);
}
}
}
return array;
}
//选择排序
function selectSort(array){
let len = array.length;
let indexmin;
for(let i=0;i<len-1;i++){
indexmin = i;
for(let j=i;j<len;j++){
if(array[i]>array[j]){
indexmin = j;
}
}
if(i!=indexmin){
swap(array,i,indexmin);
}
}
return array;
}
//插入排序
function insertSort(array){
let len = array.length;
let tmp;
for(let i=1;i<len;i++){
tmp = array[i];
let j = i;
while(j>0 && array[j-1]>tmp){
array[j] = array[j-1];
j--;
}
array[j]= tmp;
}
return array;
}
//归并排序
function mergeSort(list) {
var length = list.length;
if(length==1){ //结束条件
return list;
}
var mid = Math.floor(length/2);
var left = list.slice(0,mid);
console.log(left);
var right = list.slice(mid,length);
return merge(mergeSort(left),mergeSort(right));//递归
};
function merge(left,right) {
var result = [];
var nl = 0;
var nr =0;
while(nl<left.length && nr<right.length){
if(left[nl]<right[nr]){//按从小到大的顺序排列新的组合数组
result.push(left[nl++]);//扔进去之后迭代
}else{
result.push(right[nr++]);
}
}
while(nl<left.length){//剩下的一股脑儿扔进去。
result.push(left[nl++]);
}
while(nr<right.length){
result.push(right[nr++]);
}
return result;
}
//快速排序
function quick(array){
if(array.length<=1){
return array;
}
let mid = Math.floor(array.length/2);
let midValue = array.splice(mid,1)[0];
let arrleft = [],
arrright = [];
for(let i=0;i<array.length;i++){
let item = array[i];
item<midValue?arrleft.push(item):arrright.push(item);
}
return quick(arrleft).concat(midValue,quick(arrright));
}
var arr =[5,4,3,2];
var s = quick(arr);
console.log(s);