2021-07-11-常见排序算法

本系列算法整理自：
https://github.com/hustcc/JS-Sorting-Algorithm
https://github.com/hustcc/JS-Sorting-Algorithm
https://www.runoob.com/w3cnote/ten-sorting-algorithm.html
https://www.runoob.com/w3cnote/ten-sorting-algorithm.html

冒泡排序，选择排序，插入排序，快速排序。

1. 算法步骤【冒泡排序】

1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3）针对所有的元素重复以上的步骤，除了最后一个。
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2. 动图演示【冒泡排序】
   
3. 代码实现【冒泡排序】

C 语言 代码实现---冒泡排序

#include <stdio.h>
void bubble_sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main() {
        int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
        int len = (int) sizeof(arr) / sizeof(*arr);
        bubble_sort(arr, len);
        int i;
        for (i = 0; i < len; i++)
            printf("%d ", arr[i]);
        return 0;
}

JavaScript 代码实现---冒泡排序

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

4. 算法步骤【选择排序】

1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3）重复第二步，直到所有元素均排序完毕。

5. 动图演示【选择排序】
   
6. 代码实现【选择排序】

C 语言 代码实现---选择排序

void swap(int *a,int *b) //交换两个整数
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
void selection_sort(int arr[], int len)
{
    int i,j;

    for (i = 0 ; i < len - 1 ; i++)
    {
        int min = i;
        for (j = i + 1; j < len; j++) {  //走访未排序的元素
            if (arr[j] < arr[min]) {     //找到目前最小值
                min = j;    //记录最小值
            }
        }
        swap(&arr[min], &arr[i]);    //做交换
    }
}

JavaScript 代码实现---选择排序

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

7. 算法步骤【插入排序】

1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

8. 动图演示【插入排序】
   
9. 代码实现【插入排序】

C 语言 代码实现---插入排序

void insertion_sort(int arr[], int len) {
    int i,j,key;
    for (i=1;i<len;i++) {
        key = arr[i];
        j = i-1;
        while((j>=0) && (arr[j]>key)) {  //当前元素和已经有序的数据元素队列从后向前逐个比较，直至有序队列第一个元素也参与比较，才算本轮完成
            arr[j+1] = arr[j]; //升序（或降序）排列，则大于（或小于）当前元素的数据元素均向后后移一个位置
            j--;
        }
        arr[j+1] = key;
    }
}

JavaScript 代码实现---插入排序

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

10. 算法步骤【快速排序】

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

11. 动图演示【快速排序】
    
12. 代码实现【快速排序】

C 语言 代码实现---快速排序

typedef struct _Range {
    int start, end;
} Range;

Range new_Range(int s, int e) {
    Range r;
    r.start = s;
    r.end = e;
    return r;
}

void swap(int *x, int *y) {
    int t = *x;
    *x = *y;
    *y = t;
}

void quick_sort(int arr[], const int len) {
    if (len <= 0) {
        return; // 避免len等于负值时引发段错误（Segment Fault）
    }
    // r[]模拟列表,p为数量,r[p++]为push,r[--p]为pop且取得元素
    Range r[len];
    int p = 0;
    r[p++] = new_Range(0, len - 1);
    while (p) {
        Range range = r[--p];
        if (range.start >= range.end) {
            continue;
        }
        int mid = arr[(range.start + range.end) / 2]; // 选取中间点为基准点
        int left = range.start, right = range.end;
        do {
            while (arr[left] < mid) {
                ++left;       // 检测基准点左侧是否符合要求
            }
            while (arr[right] > mid) {
                --right;      // 检测基准点右侧是否符合要求
            }
            if (left <= right) {
                swap(&arr[left], &arr[right]);
                left++;
                right--;      // 移动指针以继续
            }
        } while (left <= right);
        
        if (range.start < right) {
            r[p++] = new_Range(range.start, right);
        }
        if (range.end > left) {
            r[p++] = new_Range(left, range.end);
        }
    }
}

JavaScript 代码实现---快速排序

function quickSort(arr, left, right) {
    var len = arr.length,
        partitionIndex,
        left = typeof left != 'number' ? 0 : left,
        right = typeof right != 'number' ? len - 1 : right;

    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex-1);
        quickSort(arr, partitionIndex+1, right);
    }
    return arr;
}

function partition(arr, left ,right) {     // 分区操作
    var pivot = left,                      // 设定基准值（pivot）
        index = pivot + 1;
    for (var i = index; i <= right; i++) {
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }        
    }
    swap(arr, pivot, index - 1);
    return index-1;
}

function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

function partition2(arr, low, high) {
    let pivot = arr[low];
    while (low < high) {
        while (low < high && arr[high] > pivot) {
            --high;
        }
        arr[low] = arr[high];
        
        while (low < high && arr[low] <= pivot) {
            ++low;
        }
        arr[high] = arr[low];
    }
    arr[low] = pivot;
    return low;
}

function quickSort2(arr, low, high) {
    if (low < high) {
        let pivot = partition2(arr, low, high);
        quickSort2(arr, low, pivot - 1);
        quickSort2(arr, pivot + 1, high);
    }
    return arr;
}

13. 算法步骤【归并排序】

1）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
2）设定两个指针，最初位置分别为两个已经排序序列的起始位置；
3）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
4）重复步骤 3 直到某一指针达到序列尾；
5）将另一序列剩下的所有元素直接复制到合并序列尾。

14. 动图演示【归并排序】
    
15. 代码实现【归并排序】

C 语言 代码实现---归并排序

int min(int x, int y) {
    return x < y ? x : y;
}

void merge_sort(int arr[], int len) {
    int *a = arr;
    int *b = (int *) malloc(len * sizeof(int));
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg * 2) {
            int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2) {
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            }
            while (start1 < end1) {
                b[k++] = a[start1++];
            }
            while (start2 < end2) {
                b[k++] = a[start2++];
            }
        }
        int *temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++) {
            b[i] = a[i];
        }
        b = a;
    }
    free(b);
}

JavaScript 代码实现---归并排序

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);
    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;
}