冒泡排序
算法复杂度:O(n^2)
var array = [5,9,4,1,10];
this.getArray = function() {
return array;
}
var swap = function(i, j) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
};
this.bubbleSort = function() {
for(var i = 1; i < array.length; i++) {
for (var j = 0; j < i; j++) {
if(array[i] < array[j]){
swap(i, j);
}
}
}
};
冒泡排序就是遍历整个数组,对每个元素再遍历其之前的元素,若存在比其大的就进行交换。
选择排序
算法复杂度:O(n^2)
this.selectionSort = function() {
minIndex = 0;
for(var i = 0; i< array.length; i++) {
minIndex = i;
for(var j = i+1; j < array.length; j++) {
if(array[minIndex] > array[j]) {
minIndex = j;
}
}
if(minIndex != i) {
this.swap(i, minIndex);
}
}
};
选择排序的思想就是遍历一遍数组,对每个元素记录其下标为最小下标,再遍历该元素之后的元素,若存在比其小的元素,则将最小下标改为其最小下标。遍历完后就进行交换。
插入排序
算法复杂度:O(n^2)
this.insertSort = function() {
for(var i = 1; i < array.length; i++) {
temp = array[i];
j = i;
while(j>0 && array[j-1]>temp) {
array[j] = array[j-1];
j--;
}
array[j] = temp;
}
};
假设数组的第一个已经是排好的。从数组第二个开始,记录其值,并逐个比较其后元素,若存在比其大的,将位置给那个较大的数字,并继续往前比较,直到比较到一个比自己小的数字就可以结束了。
归并排序
算法复杂度:O(nlogn)
this.mergeSort = function() {
array = mergeSortRecursive(array);
};
//递归执行,直到分成长度为1的数组为止
var mergeSortRecursive = function(array) {
if(array.length == 1) {
return array;
}
var middle = Math.round(array.length / 2);
var arrayLeft = array.slice(0, middle);
var arrayRight = array.slice(middle, array.length);
return merge(mergeSortRecursive(arrayLeft), mergeSortRecursive(arrayRight));
};
//将两个数组进行合并
var merge = function(arrayLeft, arrayRight) {
var result = [];
console.log("left",arrayLeft);
console.log("right",arrayRight);
var leftLen = 0;
var rightLen = 0;
//不断循环比较,直到其中一个数组全部放入result中
while(leftLen < arrayLeft.length && rightLen < arrayRight.length){
if(arrayLeft[leftLen] < arrayRight[rightLen]) {
result.push(arrayLeft[leftLen]);
leftLen++;
} else {
result.push(arrayRight[rightLen]);
rightLen++;
}
}
//剩下的数组因为是排好序的了,直接放入
while(leftLen < arrayLeft.length) {
result.push(arrayLeft[leftLen]);
leftLen++;
}
while(rightLen < arrayRight.length) {
result.push(arrayRight[rightLen]);
rightLen++;
}
return result;
};
归并排序的原理就是将一个数组不断分,分到不能分为止(长度为1的数组)就可以开始合并。
快速排序
算法复杂度:O(nlogn)
this.quickSort = function() {
quick(array, 0, array.length-1);
};
var quick = function (array, left, right) {
if(array.length > 1) {
index = partition(array, left, right);
if(left < index - 1) {
quick(array, left, index-1);
}
if(right > index) {
quick(array, index, right);
}
}
return array;
};
var partition = function(array, left, right) {
var i = left;
var j = right;
var pivot = array[Math.floor((left+right)/2)];
while(i <= j) {
while(array[i] < pivot) {
i++;
}
while(array[j] > pivot) {
j--;
}
if(i <= j) {
swap(i, j);
i++;
j--;
}
}
console.log(array, i, j);
return i;
};
快速排序的原理和归并差不多都是将数组不断分,但是快速排序是从大的开始分而归并是从小的开始。
先找到一个中间值,下标为i的元素表示中间左侧元素,下标为j的元素表示中间右侧元素,i不断找比中间值大的下标,而j不断找比中间值小的下标,一旦i<=j就进行交换。
这样就能保证i下标及以后的元素都是比中间值大的,i下标以前的元素则是比中间值小的。这样直到元素只有一个时就是排好序得了。