1、冒泡排序
算法介绍:
1、比较相邻的 两个元素,如果前一个比后一个大,则交换位置;
2、第一轮的时候最后一个元素应该是最大的一个;
3、按照步骤一的方法进行相邻两个元素大的比较,而最后一个不用比较(已最大)。
最坏时间复杂度:o(n^2),最好时间复杂度:o(n^2);
function bubble_sort(arr) {
for(var i=0;i<arr.length-1;i++){
for(var j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
var temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
bubble_sort(arr);
2、快速排序
算法介绍:
1、第一趟排序时将数据分成两部分,一部分比另一部分的所有数据都要小;
2、然后递归调用,在两边都实行快速排序。
function quick_sort(arr){
if(arr.length<=1){
return arr;
}
var pivotIndex = Math.floor(arr.length/2);
var pivot = arr.splice(pivotIndex,1)[0];//
var left = [];
var right = [];
for(var i=0;i<arr.length;i++){
if(arr[i]<pivot){
left.push(arr[i]);
}
else{
right.push(arr[i]);
}
}
return quick_sort(left).concat([pivot],quick_sort(right));
}
quick_sort(arr);
3、插入排序
算法介绍:
1、从第一个元素开始,该元素可以认为已经被排序;
2、取出下一个元素,在已经排序的元素序列中从后向前扫描;
3、如果扫描元素大于取出元素,则扫描元素往后移;
4、重复步骤3,直到找到扫描元素中小于或等于取出元素的位置;
5、将取出的元素插入到下一位置中,并重复2。
最坏时间复杂度:o(n^2),最好时间复杂度:o(n);
function insert_sort(arr) {
for(var i=1;i<arr.length;i++){
var j = i;
var key = arr[j];
while(--j>-1){
if(arr[j]>key){
arr[j+1] = arr[j];
}
else{
break;
}
}
arr[j+1] = key;
}
return arr;
}
insert_sort(arr);
4、选择排序
算法介绍:
1、令i=0,从 i 到 length-1 开始循环,找到待排数组中的最小值放在i位置上;
2、重复步骤 1;
最坏时间复杂度o(n^2);最好时间复杂度o(n^2);
function select_sort(arr) {
for(var i=0;i<arr.length-1;i++){
var min = i;
for(var j=i+1;j<arr.length;j++){
if(arr[min] > arr[j]){
min = j;
}
}
if(min != i){
var temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
return arr;
}
select_sort(arr);
5、希尔排序
算法介绍:
1、选取一个增量d,初始值是Math.floor(len/2);
2、将数组中间隔为增量d的组成新的分组,然后对这个分组的元素排序,完成排序后,增量除以2得到新的增量,d = d/2;
3、重复步骤2,直到增量为1,间隔为1的元素组成的分组就是整个数组,然后在对整个数组进行插入排序。
平均复杂度:o(log2n),最好情况复杂度:o(n);不稳定;
function shell_sort(arr) {
for(var gap = Math.floor.apply(arr.length/2);gap>0;gap = Math.floor(gap/2)){
for(var i=gap;i<arr.length;i++){
for(var j=i-gap;j>=0&&arr[j]>arr[j+gap];j-=gap){
var temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
return arr;
}
shell_sort(arr);
6、归并排序
算法介绍:
归并排序其实与希尔排序类似,主要区别在于分割数组的方式,主要思想是递归将数组层层分割,直到分割成最小的单元,然后再比较,提供一个新的数组,将分割的左右两个数组中小的数放进数组,然后再层层回溯向上合并,得到排序后的数组
平均时间复杂度为o(nlog2n),最好时间复杂度o(nlog2n);
function mergerArray(left,right) {
while(left.length>0 && right.length>0){
if(left[0] < right[0]){
result.push(left.shift());
}
else{
result.push(right.shift());
}
}
return result.concat(left).concat(right);
}
function merger_sort(arr) {
if(arr.length <= 1){
return arr;
}
var midlle = Math.floor(arr.length/2);
var left = arr.slice(0,midlle);
var right = arr.slice(middle);
return mergerArray(merger_sort(left),merger_sort(right));
}
merger_sort(arr);