算法学习—排序

排序算法

一、选择排序

1.算法简介

选择排序是一个简单直观的排序方法，它的工作原理很简单，首先从未排序序列中找到最大的元素，放到已排序序列的末尾，重复上述步骤，直到所有元素排序完毕。

2.算法描述

1）假设未排序序列的第一个是最大值，记下该元素的位置，从前往后比较
2）若某个元素比该元素大，覆盖之前的位置
3）重复第二个步骤，直到找到未排序的末尾
4）将未排序元素的第一个元素和最大元素交换位置
5）重复前面几个步骤，直到所有元素都已经排序。

3.算法分析

选择排序的交换操作次数最好情况已经有序为0次，最坏情况逆序n-1次，因此交换操作次数位于0_{(n-1)次之间；比较操作次数（n-1+…+2+1+0）为n(n-1)/2次；交换元素赋值操作为3次，逆序需要n-1趟交换，因此，赋值操作位于0}3(n-1)次之间。由于需要交换位置，所以肯定是不稳定的。

时间复杂度均为o(n^2) 空间复杂度为o(1) 不稳定

4.代码实现

//选择排序
function selsetSort(arr){
	var len = arr.length;
	for(var i=0;i<len-1;i++){
		for(var j=i+1;j<len;j++){
			if(arr[i] > arr[j]){//寻找最小值
                var temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
			}
		}
	}
	return arr;
}

二、冒泡排序

1.算法简介

列表每两个相邻的数进行比较，如果前面的数比后面的数大，则交换这两个数，一轮排序完成后，则无序区减少一个数，有序区增加一个数。

2.算法描述

1）快速排序的特点就是随机设置一个基准点，比如是数组的第一个元素，然后数组的其他元素就跟这个基准线进行对比，比基准线大的放在左边，比基准线小的放在右边
2）再设置一个基准线，再这样小的放左边，大的放右边，递归。

3.算法分析

平均时间复杂度O(nn) 、最好情况O(n)、最差情况O(nn)

空间复杂度O(1) 稳定

4.代码实现

 function sort(arr){
     let len = arr.length;
     for (let i = 0; i < len - 1 ; i++) {
         // 用来标记在一轮冒泡过程中有无交换过
         let flag = false;
         for (let j = 0; j < len - i; j++) {
             if(arr[j] > arr[j+1]){
                 // 交换两个数
                 let temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
                 flag = true;
             }
         }
         // 如果在一轮冒泡过程中没有交换过，说明此时的列表已经是排序好的了，直接结束循环
         if(!flag){
             return;
         }
     } 
 }
let arr = [2,3,1,4,8,7,9,6];
this.sort(arr;
console.log(arr); 

三、插入排序

1.算法简介

所谓插入排序，就是把最小的（或者最大的），一次次插入到最前面，从而达到排序的效果

2.算法描述

刚开始将整个数组看作一个无序区，每一轮拿无序区的第一数与有序区的数从后往前依次进行比较，遇到更大的数则交换，每一轮排序完成后，有序区增加一个数，无序区减少一个数。

3.算法分析

时间复杂度是O(n*n) 空间复杂度为o(1) 稳定

4.代码实现

function sort(arr){
    let len = arr.length;
    for (let i = 1; i < len; i++) {
        for (let j = i - 1; j >= 0 ; j--) {
            if(arr[j] > arr[j+1]){
                let temp = arr[j+1]
                arr[j+1] = arr[j]
                arr[j] = temp
            }  
        }  
    }
}, 

四、快速排序

1.算法简介

采用“分治”的思想，对于一组数据，选择一个基准元素（base），通常选择第一个或最后一个元素，通过第一轮扫描，比base小的元素都在base左边，比base大的元素都在base右边，再有同样的方法递归排序这两部分，直到序列中所有数据均有序为止。快速排序算法的性能比冒泡、选择排序都要好，和归并排序一样，是一个可以用于实战的算法。

2.算法描述

1）快速排序的特点就是随机设置一个基准点，比如是数组的第一个元素，然后数组的其他元素就跟这个基准线进行对比，比基准线大的放在左边，比基准线小的放在右边
2）再设置一个基准线，再这样小的放左边，大的放右边，递归。

3.算法分析

时间复杂度是O(nlogn) 空间复杂度为o(logn) 不稳定

4.代码实现

 function sort(arr,l,r){
     if(l < r){
         let i = l;
         let j = r;
         let mid = arr[l];
         while(i < j){
             while(arr[j] > mid && i < j){
                 j--;
             }
             arr[i] = arr[j];
             while(arr[i] < mid && i < j){
                 i++;
             }
             arr[j] = arr[i];
         }
         arr[i] = mid
         this.test(arr,l,i-1)
         this.test(arr,i+1,j)
         return arr
     }else{
         return
     }
 }, 
 // 测试数据
let arr = [2,3,1,4,8,7,9,6];
let res = this.sort(arr,0,7);
console.log(res); 

五、归并排序

1.算法简介

使用分而治之的概念对给定的元素列表进行排序。它将问题分解为较小的子问题，直到它们变得足够简单以至可以直接解决为止。

2.算法描述

1）将给定的列表分为两半（如果列表中的元素数为奇数，则使其大致相等）。

2）以相同的方式继续划分子数组，直到只剩下单个元素数组。

3）从单个元素数组开始，合并子数组，以便对每个合并的子数组进行排序。

4）重复第 3 步单元，直到最后得到一个排好序的数组。

3.算法分析

时间复杂度是O(nlogn) 空间复杂度为O(n) 稳定

4.代码实现

function sort(arr){
    if(arr && arr.length > 1){
        const mid = Math.floor(arr.length/2)
        const left = arr.slice(0,mid)
        const right = arr.slice(mid);
        return this.merge(this.sort(left), this.sort(right))
    }
    return arr
},
function merge(leftList, rightList){
    const newList = [];
    const leftLength = leftList && leftList.length;
    const rightLength = rightList && rightList.length;
    let i = 0;
    let j = 0;
    while (i < leftLength && j < rightLength) {
        if (leftList[i] < rightList[j]) {
            newList.push(leftList[i++]);
        } else {
            newList.push(rightList[j++]);
        }
    }
    while (i < leftLength) {
        newList.push(leftList[i++]);
    }
    while (j < rightLength) {
        newList.push(rightList[j++]);
    }
    return newList;
}, 

六、堆排序

1.算法简介

堆是一种特殊的完全二叉树，堆分为大根堆和小根堆，满足任一节点都比其孩子节点大的一个完全二叉树就是大根堆，满足任一节点都比其孩子节点小的一个完全二叉树就是小根堆。

2.算法描述

首先构造一个大根堆（此时整个堆是无序区），然后将堆顶的元素取出放到有序区（也就是数组的最后），然后将堆的最后一个元素（也就是无序区的最后一个元素）放到堆顶，堆就少了一个元素，此时通过一次向下调整重新使堆有序，调整后的堆顶就是整个数组的第二大元素，然后重复之前的操作依次将元素放到有序区，直到堆变空，便可得到排序好的数组。

3.算法分析

时间复杂度是O(nlogn) 空间复杂度为O(1) 不稳定

4.代码实现

function sort(list) {
    if (list && list.length > 1) {
        const len = list.length;
        // 首先构造大根堆，从最后一个不是叶子节点的节点开始遍历，从后往前依次进行向下调整
        for (let i = Math.floor((len-2)/2); i>=0; i--) {
            sift(list, i, len-1);
        }
        // 然后将堆的第一元素与有序区的第一个元素进行交换，此时有序区增加一个，无序区减少一个，再进行一次堆的向下调整，然后重复上述操作，最终使整个数组有序
        for(let i = len-1; i>=0; i--){
            const m = list[0];
            list[0] = list[i];
            list[i] = m;
            sift(list, 0, i-1);
        } 
    }
}

/**
* 堆的向下调整
* 先从根节点开始，如果孩子节点比父节点大，则将该孩子节点赋值给父节点
* 然后指针指向下一层，重复上面的操作，直到找到孩子节点没有比父节点大的节点，终止循环
* 最后将原始的根节点赋值给当前父节点
*/
function sift(li, low, high) {
    const tmp = li[low]; // 缓存根节点
    let i = low; // 当前的父节点，最开始指向根节点
    let j = i*2+1; // 当前的孩子节点，最开始指向根节点的左孩子节点

    while (j <= high) {
        // 如果有右孩子节点且比左孩子节点大，则j指向右孩子节点
        if (j+1 <= high && li[j+1] > li[j]) {
            j++;
        }
        if (li[j] > tmp) {
            li[i] = li[j]; // 将较大的孩子节点赋值给父节点
            i = j; // i指向下一层
            j = i*2 +1;
        } else {
            break; // 如果当前子节点没有比原始根节点大，结束循环
        }
    }

    li[i] = tmp; // 最后将原始的根节点赋值给当前父节点
}

总结