排序的常用算法

前言:

(1)排序的定义:对一序列对象根据某个关键字进行排序;

输入:n个数:a1,a2,a3,…,an
输出:n个数的排列:a1′,a2′,a3′,…,an’,使得a1′<=a2′<=a3′<=…<=an’。

再讲的形象点就是排排坐,调座位,高的站在后面,矮的站在前面。

(2)对于评述算法优劣术语的说明

稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;
不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;

内排序:所有排序操作都在内存中完成;
外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;

时间复杂度: 一个算法执行所耗费的时间;

空间复杂度: 运行完一个程序所需内存的大小。

(3)排序算法总结

《排序的常用算法》

n: 数据规模
k:“桶”的个数
In-place: 占用常数内存,不占用额外内存

Out-place: 占用额外内存

1、冒泡排序(Bubble Sort)

(1)算法描述:

从数组开头开始遍历,需要遍历数组长度的次数。每一次遍历,依次比较相邻的两个元素,如果它们的顺序错误就进行交换。每一次遍历完成就会排好一个最大数或者最小数

(2)代码实现:

function bubbleSort(arr) {
    let len = arr.length;
    for (let i = 0; i < len; i++) {
        for (let j = 0; j < len - 1 - i; j++) {
	    if (arr[j] > arr[j+1]) {        //相邻元素两两对比
	        let temp = arr[j+1];        //元素交换
	        arr[j+1] = arr[j];
	        arr[j] = temp;
            }
        }
    }
    return arr;
}

改进冒泡排序: 设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

function bubbleSort2(arr) {
    let i = arr.length-1;    //初始时,最后位置保持不变
    while ( i> 0) {
        let pos = 0;     //每趟开始时,无记录交换
        for (let j = 0; j< i; j++){
     if (arr[j]> arr[j+1]) {
                pos= j;    //记录交换的位置
         let tmp = arr[j];
         arr[j] = arr[j+1];
         arr[j+1] = tmp;
      }
        }  
 i = pos;     //为下一趟排序作准备
    }
    return arr;
}

(3)性能分析:

  • 最佳性能:T(n) = O(n)   当输入的数据为正序时
  • 最差性能:T(n) = O(n^2)   当输入的数据为反序时

2、选择排序(Selection Sort)

(1)算法描述:

首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾

(2)代码实现:

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

(3)性能分析:

  • 最佳情况:T(n) = O(n^2)
  • 最差情况:T(n) = O(n^2)
  • 平均情况:T(n) = O(n^2)

3、插入排序

(1)算法描述:

从第一个元素开始,认为该元素已经排序,然后取下一个元素,在已排序序列中从后往前扫描,找到合适的位置插入

(2)代码实现:

function insertSort(arr) {
    let len = arr.length;
    for (let i = 1; i < len; i++) {
	let key = arr[i];
        let j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
         }
         arr[j + 1] = key;
    }
    return arr;
}

改进插入排序:在寻找插入位置的时候,可以使用二分查找的方法。

(3)性能分析:

  • 最佳情况:输入数组按升序排列。T(n) = O(n)
  • 最坏情况:输入数组按降序排列。T(n) = O(n^2)
  • 平均情况:T(n) = O(n^2)

4、希尔排序

(1)算法描述:

将整个带排序的序列数组分割成为若干子序列,然后分别对于子序列进行插入排序

(2)代码实现:

function shellSort(arr) {
    let len = arr.length;
    let temp;
    let gap = 1;
    while(gap < len/5) {          //动态定义间隔序列
        gap = gap*5+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/5)) {
        for (let i = gap; i < len; i++) {
            temp = arr[i];
            for (let j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

(3)性能分析:

  • 最佳情况:T(n) = O(nlog2 n)
  • 最坏情况:T(n) = O(nlog2 n)
  • 平均情况:T(n) =O(nlog n)

5、归并排序

(1)算法描述:

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。

(2)代码实现:

function mergeSort(arr) {  //采用自上而下的递归方法
    let len = arr.length;
    if(len < 2) {
        return arr;
    }
    let middle = Math.floor(len / 2);
    let left = arr.slice(0, middle);
    let right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right)
{
    let 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());
  
    return result;
}

(3)性能分析:

  • 最佳情况:T(n) = O(n)
  • 最差情况:T(n) = O(nlogn)
  • 平均情况:T(n) = O(nlogn)

6、快速排序

(1)算法描述:

通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序

(2)代码实现:

function quickSort(array, left, right) {
if (left < right) {
    var x = array[right], i = left - 1, temp;
    for (var j = left; j <= right; j++) {
        if (array[j] <= x) {
            i++;
            temp = array[i];
            array[i] = array[j];
            array[j] = temp;
         }
     }
     quickSort(array, left, i - 1);
     quickSort(array, i + 1, right);
}
    return array;
}

//方法二var quickSort2 = function(arr) {  if (arr.length <= 1) { return arr; }  let 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 quickSort2(left).concat([pivot], quickSort2(right));};

(3)性能分析:

  • 最佳情况:T(n) = O(nlogn)
  • 最差情况:T(n) = O(n2)
  • 平均情况:T(n) = O(nlogn)

7、堆排序

(1)算法描述:

利用堆这种数据结构的特性,将默认的数据构成无序堆,然后调整为大根堆(或者小根堆),将堆顶的数值沉到最后(相当于找出了一个最大值或者最小值)然后接着依次调整,直到排序完成。

(2)代码实现:

/*方法说明:堆排序
@param  array 待排序数组*/
function heapSort(array) {
 //建堆
 var heapSize = array.length, temp;
 for (var i = Math.floor(heapSize / 2) - 1; i >= 0; i--) {
     heapify(array, i, heapSize);
 }
 //堆排序
 for (var j = heapSize - 1; j >= 1; j--) {
     temp = array[0];
     array[0] = array[j];
     array[j] = temp;
     heapify(array, 0, --heapSize);
 }
 return array;

}/*方法说明:维护堆的性质@param arr 数组@param x 数组下标@param len 堆大小*/function heapify(arr, x, len) { if (Object.prototype.toString.call(arr).slice(8, -1) === ‘Array’ && typeof x === ‘number’) { var l = 2 * x + 1, r = 2 * x + 2, largest = x, temp; if (l < len && arr[l] > arr[largest]) { largest = l; } if (r < len && arr[r] > arr[largest]) { largest = r; } if (largest != x) { temp = arr[x]; arr[x] = arr[largest]; arr[largest] = temp; heapify(arr, largest, len); } } else { return ‘arr is not an Array or x is not a number!’; }}

(3)性能分析:

  • 最佳情况:T(n) = O(nlogn)
  • 最差情况:T(n) = O(nlogn)
  • 平均情况:T(n) = O(nlogn)

【注】

参考博客地址:点击打开链接点击打开链接

点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注