目录
冒泡排序
选择排序
插入排序
归并排序
快速排序
冒泡排序
一句话描述就是较高的往后站。
步骤如下:
1. 从第一个数开始,如果第一个比第二个大,就交换两个,把大的数往后放。
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样轮完一遍之后,最大的数必定在最后一位。
3. 再次遍历,重复步骤1,2,但是只遍历到最后一个数的前一个。
//用来互换两个数位置的swap函数
function swap(array,a,b){
var temp = array[a]
array[a] = array[b]
array[b] = temp
}
function bubbleSort(arr) {
var len = arr.length
for(var i = 0; i < len; i++){
for(var j = 0; j < len - 1 - i; j++){
if(arr[j] > arr[j+1]){
swap(arr,j,j+1)
}
}
}
return arr
}
时间复杂度:O(n^2)
最好情况:O(n)//正序数组
最差情况:O(n^2)//倒序数组
空间复杂度:O(1)
稳定性:稳定
选择排序
一句话说明就是最矮的到最前面
步骤如下:
1. 将指针指向第一个元素,并标记为最小元素
2. 遍历整个数组,直至遍历完后找到比它小的最小元素,然后交换两者位置。
3. 重复第一步,但是从第二个元素开始遍历,然后重复第二步
function swap(array, a, b) {
var temp = array[a]
array[a] = array[b]
array[b] = temp
}
function selectionSort(arr) {
var len = arr.length;
var minIndex, temp;
for (var i = 0; i < len; i++) {
minIndex = i;
for (var j = i + 1; j < len - 1; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j
}
}
//如果数组第一个数是最小的话,就不交换,否则才换
if (minIndex !== i) {
swap(arr, i, minIndex)
}
}
return arr
}
时间复杂度:O(n^2)
最好情况:O(n^2)
最差情况:O(n^2)
空间复杂度:O(1)
稳定性:不稳定//[5,5,2]
插入排序
一句话说明:摸牌算法
我们拿牌的时候,每拿到一张新牌,就会和手中已有的牌进行比较,大的放右边,小的放在左边。
步骤如下:
1. 从第一个元素开始,这个元素被认为已经被排序
2. 然后拿到下一个元素,在已经排序的元素中从后向前扫描,如果新元素比我们已排的元素小,就把已排元素向后排一位
3. 接着从后往前遍历,知道找到已排序的元素小于或者等于新元素,把新元素插入到该元素后面
function insertionSort(arr) {
var len = arr.length,
key, i, j;
for (j = 1; j < len; j++) {
key = arr[j]
i = j - 1
while (i >= 0 && arr[i]>key){
arr[j] = arr[i]
i--
}
arr[i+1] = key
}
return arr
}
时间复杂度:O(n^2)
最好情况:O(n)//升序排列
最差情况:O(n^2)//降序排列
空间复杂度:O(1)
稳定性:稳定
归并排序
一句话说明,就是分治,将已有的子序列归并,得到完全有序的序列。
步骤如下:
1. 将长度为n的数组分为两半,然后再将两个子数组再次对半分,不停对半分,直至最小子数组中只有两个数。
2. 然后排序,向上一级再次排序,这样不停归并,直到合起来的最终数组有序
//递归,分到不能分为止
function mergeSort(arr){
var len = arr.length
if(len < 2){
return arr
}
var middle = Math.floor(len / 2),
left = arr.slice(0,middle),
right = arr.slice(middle);
//arr不变,创建了两个新的数组
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())
}
return result
}
时间复杂度:O(n log n)
最好情况:O(n log n)
最差情况:O(n log n)
空间复杂度:O(n)
稳定性:稳定
快速排序
一句话说明,自私算法,让每个元素找到自己的位置。
function quickSort(arr) {
var len = arr.length;
if (len < 2) {
return arr
}
var pivotIndex = Math.floor(len / 2);
var pivot = arr.splice(pivotIndex, 0)
var left = [],
right = [];
for(var i = 0; i < len;i++){
if(arr[i] < pivot){
left.push(arr[i])
}else{
right.push(arr[i])
}
}
return quickSort(left.concat([pivot]),quickSort(right))
}
时间复杂度:O(n log n)
最好情况:O(n log n)
最差情况:O(n^2)
空间复杂度:O( log n )
稳定性:不稳定