常见排序算法介绍(JS版)

本文是之前写的一篇js版的算法介绍。

插入排序

将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表。

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

希尔排序

缩小增量的插入排序,先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行依次直接插入排序。

function shellSort(arr) {
    let len = arr.length;
    let inc = parseInt(len / 2);
    while(inc > 0){
        for(let i = inc; i < len; i++) {
            let temp =  arr[i];
            for(var j = i; j >= inc && arr[j-inc] > temp; j -= inc) {
                arr[j] = arr[j-inc];
            }
            arr[j] = temp;
        }
        inc = parseInt(inc / 2);
    }
}

选择排序

在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换;然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止。

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

堆排序

堆排序是一种树形选择排序,是对直接选择排序的有效改进

function heapSort(arr) {
    buildHeap(arr);
    console.log(arr);
    for(let i = arr.length - 1; i >= 0; i--) {
        [arr[i], arr[0]] = [arr[0], arr[i]];
        AdjustHeap(arr, 0, i);
    }
}

function buildHeap(arr) {
    let len = arr.length;
    for(let i = Math.floor(len / 2) - 1; i >= 0; i--) {
        AdjustHeap(arr, i, len);
    }
}

function AdjustHeap(arr, idx, len) {
    // let len = arr.length;
    let left = 2 * idx + 1;
    while(left < len) {
        if(left+1 < len && arr[left] < arr[left+1]) {
            left++;
        }
        if(arr[idx] < arr[left]) {
            [arr[idx], arr[left]] = [arr[left], arr[idx]];
            idx = left;
            left = idx * 2 + 1;
        } else {
            break;
        }
    }
}

冒泡排序

每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

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

设置标志位,对冒泡排序进行改进。

function bubleSort2(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]) {
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
                pos = j;
            }
        }
        i  = pos;
        console.log(pos);
    }
}

快速排序

选择一个基准元素,通常选择第一个元素或者最后一个元素;通过一趟排序讲待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小,另一部分记录的 元素值比基准值大;此时基准元素在其排好序后的正确位置;然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。

function quickSort(arr, start, end) {
    if(start < end) {
        let left = start, right = end;
        let mid = arr[left];
        while(left < right) {
            while(left < right && arr[right] >= mid) right--;
            [arr[left], arr[right]] = [arr[right], arr[left]];
            while(left < right && arr[left] <= mid) left++;
            [arr[left], arr[right]] = [arr[right], arr[left]]; 
        }
        quickSort(arr, start, left-1);
        quickSort(arr, left+1, end);
    }
}

归并排序

归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

function mergeSort(arr, start, end) {
    if(start < end) {
        let mid = Math.floor((start + end) / 2);
        mergeSort(arr, start, mid);
        mergeSort(arr, mid + 1, end);
        if(arr[mid] > arr[mid+1]) { //如果两部分已经有序,不再进行归并操作
          merge(arr, start, mid, end); 
        }
    }
}

function merge(arr, start, mid, end) {
    let i = start, j = mid+1;
    let temp = new Array(end - start + 1);
    let k = 0;
    for(; i <= mid && j <= end; ) {
        if(arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while(i<=mid) temp[k++] = arr[i++];
    while(j<=end) temp[k++] = arr[j++];
    for(let item of temp) {
        arr[start++] = item;
    }
}

归并排序的非递归做法

归并排序的非递归做法好像是面试时常遇到的问题,实现如下:

function mergeSort2(arr) {
    let step = 1;
    let temp = new Array(arr.length);
    for(; step < arr.length ; step = step*2) {
        let ls, le, rs, re;
        for(let ls = 0; ls < arr.length - step; ls = re) {
            rs = le = ls + step;
            re = rs + step;
            if(re > arr.length) {
                re = arr.length;
            }
            let k = 0;
            while(ls < le && rs < re) {
                temp[k++] = arr[ls] > arr[rs] ? arr[rs++] : arr[ls++];
            }
            while(ls < le) {
                temp[k++] = arr[ls++];
            }
            while(k > 0) {
                arr[--rs] = temp[--k];
            }
        }
    }
}

自底向上的归并排序

自底向上的归并排序也是非递归的,实现如下:

template<typename T>
void mergeSortBU(T a[], int n) {
  for(int size = 1; size <= n; size += size) {
    for(int i = 0; i+size < n; i += size + size) {
      merge(a, i, i+size-1, min(i+2*size-1, n-1));
    }
  }
}

推荐阅读更多精彩内容

  • 概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部...
    蚁前阅读 4,574评论 0 52
  • 概述:排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部...
    每天刷两次牙阅读 3,304评论 0 16
  • 概述排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的...
    Luc_阅读 1,877评论 0 35
  • 1.插入排序—直接插入排序(Straight Insertion Sort) 基本思想: 将一个记录插入到已排序好...
    依依玖玥阅读 631评论 0 2
  • 概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部...
    闲云清烟阅读 553评论 0 6
  • 最近买了一只可以刨土豆丝的武器,以前需要我用刀切5分钟,现在我只需要一分钟,而且可以把丝切的很细。 它的价格1...
    王枫浚阅读 198评论 0 1
  • 说这样的话,自然表明我性情中有急躁面,对待孩子有过粗暴表现。 凡事一旦重复发生,就有规律可循。 有一天,当我第N次...
    泠风思语阅读 230评论 0 4
  • 如题,使用windows版的curl,如curl www.baidu.com 控制台输出的是乱码. 解决办法,需要...
    凡凡的小web阅读 1,649评论 0 0
  • 今年5月中旬有幸来到上海参加了中国三明治举办的自在创意写作节,除了被无数有趣的主题活动吸引,更让我感动的是在破茧2...
    Diego伯爵阅读 1,648评论 0 3
  • Java socket应用—通信** InetAddress** 1、InetAddress 类用于标示网络上的...
    少冰三hun甜阅读 886评论 0 2