sort

微笑不守恒
30 阅读5分钟

算法分类

十种常见排序算法可以分为两大类：

非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。

线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

image.png

算法复杂度

image.png

## 相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

**空间复杂度：**是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

冒泡算法 (Bubble Sort)

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。

冒泡算法.gif

// console.log("冒泡");
let mp = [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45];

let fmp = (arr: Array<any>, type = ">") => {
    var len = arr.length;
    for (let i = 0; i < len; i++) {
        let fl = false;
        for (let j = 0; j < len - 1 - i; j++) {
            let f = false;
            if (arr[j] > arr[j + 1] && type == ">") {
                f = true;
                // 相邻元素两两对比
                // var temp = arr[j + 1]; // 元素交换
                // arr[j + 1] = arr[j];
                // arr[j] = temp;
            }
            if (arr[j] < arr[j + 1] && type == "<") {
                f = true;
                // // 相邻元素两两对比
                // var temp = arr[j + 1]; // 元素交换
                // arr[j + 1] = arr[j];
                // arr[j] = temp;
            }
            if (f) {
                fl = true;
                // 相邻元素两两对比
                var temp = arr[j + 1]; // 元素交换
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
        if (!fl) {
            // console.log(i);
            return arr;
        }
    }
};
console.log(mp);
// [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45]

console.log(fmp(mp));
// [1, 2, 4, 4, 4, 5, 7, 8, 9, 12, 45, 45]

console.log(fmp(mp, "<"));
// [45, 45, 12, 9, 8, 7, 5, 4, 4, 4, 2, 1]

选择排序 (Selection Sort)

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。

选择排序.gif

// console.log("选择排序");
let mp = [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45];
let selectionSort = (arr: Array<any>, type = ">") => {
    let len = arr.length;
    let minIndex;
    let temp;
    for (let i = 0; i < len - 1; i++) {
        minIndex = i;
        for (let j = i + 1; j < len; j++) {
            if (arr[minIndex] > arr[j] && type == ">") {
                minIndex = j;
            }
            if (arr[minIndex] < arr[j] && type == "<") {
                minIndex = j;
            }
        }
        if (i != minIndex) {
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    return arr;
};
console.log(selectionSort(mp));
// [1, 2, 4, 4, 4, 5, 7, 8, 9, 12, 45, 45]

console.log(selectionSort(mp, "<"));
// [45, 45, 12, 9, 8, 7, 5, 4, 4, 4, 2, 1]

插入排序 (Insertion Sort)

  • 从第一个元素开始，该元素可以认为已经被排序；
  • 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  • 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  • 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  • 将新元素插入到该位置后；
  • 重复步骤2~5。。

插入排序.gif

console.log("插入排序");
let mp = [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45];
let insertionSort = (arr: Array<any>, type = ">") => {
    let len = arr.length;
    let preIndex;
    let current;
    for (let i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current && type == ">") {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        while (preIndex >= 0 && arr[preIndex] < current && type == "<") {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr;
};
console.log(insertionSort(mp));
// [1, 2, 4, 4, 4, 5, 7, 8, 9, 12, 45, 45]

console.log(insertionSort(mp, "<"));
// [45, 45, 12, 9, 8, 7, 5, 4, 4, 4, 2, 1]

归并排序 (Merge Sort)

  • 把长度为n的输入序列分成两个长度为n/2的子序列；
  • 对这两个子序列分别采用归并排序；
  • 将两个排序好的子序列合并成一个最终的排序序列。

归并排序.gif

console.log("归并排序");
let mp = [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45];
let mergeSort = (arr: Array<any>, type = ">"): Array<any> => {
    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, type), mergeSort(right, type), type);
};
let merge = (left: Array<any>, right: Array<any>, type = ">"): Array<any> => {
    let result = [];
    while (left.length > 0 && right.length > 0) {
        if (type == ">") {
            if (left[0] <= right[0]) {
                result.push(left.shift());
            } else {
                result.push(right.shift());
            }
        } else {
            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;
};
console.log(mergeSort(mp));
// [1, 2, 4, 4, 4, 5, 7, 8, 9, 12, 45, 45]

console.log(mergeSort(mp, "<"));
// [45, 45, 12, 9, 8, 7, 5, 4, 4, 4, 2, 1]

快速排序 (Quick Sort)

  • 从数列中挑出一个元素，称为 “基准”（pivot）；
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

快速排序.gif

console.log("快速排序");
let mp = [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45];
let quickSort = (arr: Array<any>, left: number, right: number, type = ">") => {
    let len = arr.length;
    let partitionIndex = 0;
    if (left < right) {
        partitionIndex = quick(arr, left, right, type);
        quickSort(arr, left, partitionIndex - 1, type);
        quickSort(arr, partitionIndex + 1, right, type);
    }
    return arr;
};
let quick = (arr: Array<any>, left: number, right: number, type = ">") => {
    let len = arr.length;
    let pivot = left; // 设定基准值（pivot）
    let index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot] && type == "<") {
            // pivot  index           i
            // 3      4       5       2   1   7
            // pivot          index   i
            // 3      2       5       4   1   7

            // pivot          index       i
            // 3      2       5       4   1        7
            // pivot                      index    i
            // 3      2       1       4   5        7
            swap(arr, i, index);
            index++;
        }
        if (arr[i] > arr[pivot] && type == ">") {
            swap(arr, i, index);
            index++;
        }
    }
    // pivot          index-1
    // 3      2       1       4   5   7
    //                index-1
    // 1      2       3       4   5   7
    swap(arr, pivot, index - 1);
    return index - 1;
};
let swap = (arr: Array<any>, i: number, j: number) => {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
};
console.log(quickSort(mp, 0, mp.length));
// [45, 45, 12, 9, 8, 7, 5, 4, 4, 4, 2, 1]

console.log(quickSort(mp, 0, mp.length, "<"));
// [1, 2, 4, 4, 4, 5, 7, 8, 9, 12, 45, 45]

希尔排序 (Shell Sort)

  • 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  • 按增量序列个数k，对序列进行k 趟排序；
  • 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

希尔排序.gif

console.log("希尔排序");
let mp = [1, 5, 9, 7, 2, 8, 4, 12, 45, 4, 4, 45];
function shellSort(arr: Array<any>) {
    let len = arr.length;
    let temp;
    let gap = 1;
    while (gap < len / 3) {
        // 动态定义间隔序列
        gap = gap * 3 + 1;
    }
    for (gap; gap > 0; gap = Math.floor(gap / 3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i - gap; j > 0 && arr[j] > temp; j -= gap) {
                arr[j + gap] = arr[j];
            }
            arr[j + gap] = temp;
        }
    }
    // 此处仅为反转数组，与算法无关
    if (type != ">") {
        for (let i = 0; i <= Math.floor(len / 2); i++) {
            if (i == len - i - 1 || i > len - i - 1) {
                break;
            }
            let temp = arr[i];
            arr[i] = arr[len - i - 1];
            arr[len - i - 1] = temp;
        }
    }
    return arr;
}
console.log(shellSort(mp));
// [1, 2, 4, 4, 4, 5, 7, 8, 9, 12, 45, 45]
 
console.log(shellSort(mp, "<"));
// [45, 45, 12, 9, 8, 7, 5, 4, 4, 4, 2, 1]

堆排序 (Heap Sort)

  • 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
  • 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
  • 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

堆排序.gif

var len;   // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
 
function buildMaxHeap(arr) {  // 建立大顶堆
    len = arr.length;
    for (var i = Math.floor(len/2); i >= 0; i--) {
        heapify(arr, i);
    }
}
 
function heapify(arr, i) {    // 堆调整
    var left = 2 * i + 1,
        right = 2 * i + 2,
        largest = i;
 
    if (left < len && arr[left] > arr[largest]) {
        largest = left;
    }
 
    if (right < len && arr[right] > arr[largest]) {
        largest = right;
    }
 
    if (largest != i) {
        swap(arr, i, largest);
        heapify(arr, largest);
    }
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
 
function heapSort(arr) {
    buildMaxHeap(arr);
 
    for (var i = arr.length - 1; i > 0; i--) {
        swap(arr, 0, i);
        len--;
        heapify(arr, 0);
    }
    return arr;
}

计数排序 (Counting Sort)

  • 找出待排序的数组中最大和最小的元素；
  • 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  • 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  • 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

计数排序.gif

function countingSort(arr, maxValue) {
    var bucket =new Array(maxValue + 1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;
 
    for (var i = 0; i < arrLen; i++) {
        if (!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }
 
    for (var j = 0; j < bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }
 
    return arr;
}

桶排序 (Bucket Sort)

  • 设置一个定量的数组当作空桶；
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • 对每个不是空的桶进行排序；
  • 从不是空的桶里把排好序的数据拼接起来。
unction bucketSort(arr, bucketSize) {
    if (arr.length === 0) {
      return arr;
    }
 
    var i;
    var minValue = arr[0];
    var maxValue = arr[0];
    for (i = 1; i < arr.length; i++) {
      if (arr[i] < minValue) {
          minValue = arr[i];               // 输入数据的最小值
      }else if (arr[i] > maxValue) {
          maxValue = arr[i];               // 输入数据的最大值
      }
    }
 
    // 桶的初始化
    var DEFAULT_BUCKET_SIZE = 5;           // 设置桶的默认数量为5
    bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
    var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;  
    var buckets =new Array(bucketCount);
    for (i = 0; i < buckets.length; i++) {
        buckets[i] = [];
    }
 
    // 利用映射函数将数据分配到各个桶中
    for (i = 0; i < arr.length; i++) {
        buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
    }
 
    arr.length = 0;
    for (i = 0; i < buckets.length; i++) {
        insertionSort(buckets[i]);                     // 对每个桶进行排序，这里使用了插入排序
        for (var j = 0; j < buckets[i].length; j++) {
            arr.push(buckets[i][j]);                     
        }
    }
 
    return arr;
}

基数排序 (Radix Sort)

  • 取得数组中的最大数，并取得位数；
  • arr为原始数组，从最低位开始取每个位组成radix数组；
  • 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

基数排序.gif

/ LSD Radix Sort
var counter = [];
function radixSort(arr, maxDigit) {
    var mod = 10;
    var dev = 1;
    for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        for(var j = 0; j < arr.length; j++) {
            var bucket = parseInt((arr[j] % mod) / dev);
            if(counter[bucket]==null) {
                counter[bucket] = [];
            }
            counter[bucket].push(arr[j]);
        }
        var pos = 0;
        for(var j = 0; j < counter.length; j++) {
            var value =null;
            if(counter[j]!=null) {
                while ((value = counter[j].shift()) !=null) {
                      arr[pos++] = value;
                }
          }
        }
    }
    return arr;
}
avatar
文章
阅读
粉丝