12月19日周末总结

选择排序

选择排序是对序列进行遍历，每次遍历都找出无序部分中最小的（或最大）的数值，与第一个无序数值互换位置，不断重复此过程，知道序列有序。
由此可知，选择排序的时间性能为n方级别（因为记录交换不是在相邻单元中进行，所以是不稳定排序）

for(int i=1;i<=n;i++)
    {
        int index=i;
        for(int j=i+1;j<=n;j++)
        {
            if(a[j]<a[index])
            {
                index=j;
            }
        }
        swap(a[i],a[index]);
    }

插入排序

在插入的同时有前面的有序数列进行比较，每次插入都进行调整，调整方法可以是将待排值放入a[0]然后用a[0]不断进行比较，比他大的就与待排值交换次序。
与选择插入类似，都是n方级别的时间复杂度。

for(int i=2;i<=n;i++)
    {
        cin>>a[i];
        a[0]=a[i];
        int j=i-1;
        while(a[0]<a[j])
        {
            a[j+1]=a[j];
            j--;
            if(j<0)
                break;
        }
        a[j+1]=a[0];
    }

快速排序

快速排序是目前时间性能最低的线性排序算法，具体为对数级别乘以n，也是sort函数的原型。
该函数是设置一个标准值，然后从序列尾部开始遍历，比他大的就保持不变，小的则互换位置，然后再从序列头部开始遍历，再与比他大的互换位置，这样每次遍历后都会得到一个位置已经排好的数值，进行多次后就可以得到排好的序列。

int sorta(int i,int j)
{
    while(i<j)
    {
        while((a[j]>=a[i])&&(j>i))
        {
            j--;
        }
        if(i<j)
        {
            swap(a[i],a[j]);
            i++;
        }
        while((a[i]<=a[j])&&(j>i))
        {
            i++;
        }
        if(i<j)
        {
            swap(a[i],a[j]);
            j--;
        }
    }
    return i;
}
void qsort(int i,int j)
{
    if(i>=j)
        return;
    else
        {int t=sorta(i,j);
        qsort(i,t-1);
        qsort(t+1,j);}
}

桶排序

先创建5个桶，桶的区间跨度=(最大值-最小值)/桶的数量，注意，每个桶的范围都是包含最小值，不包含最大值，最后一个桶，既包含最小值，也包含最大值，遍历原始序列，将序列放入桶中，每个桶内部的元素分别排序，遍历所有桶，此时，元素已是有序的了。

function sort(arr) {
    // 得到数列的最大值、最小值，并计算差值d
    let max = arr[0];
    let min = arr[0];
    for (let item of arr) {
        if (item > max) {
            max = item;
        }
        if (item < min) {
            min = item;
        }
    }
    let d = max - min;
    // 初始化桶
    let bucketNum = 5;
    let bucketArr = [];
    for (let i = 0; i < bucketNum; i++) {
        bucketArr.push([]);
    }
    // 遍历原始数组，将原始放入桶中
    for (let item of arr) {
        let index = parseInt((item - min) * bucketNum / d);
        if (index === bucketNum) {
            index--;
        }
        bucketArr[index].push(item);
    }

    // 对每个桶进行排序，这里用了冒泡排序法
    for (let itemArr of bucketArr) {
        bubbleSort(itemArr);
    }

    // 遍历桶，得到排序后结果
    let index = 0;
    let sortArr = [];
    for (let itemArr of bucketArr) {
        for (let item of itemArr) {
            sortArr[index++] = item;
        }
    }

    return sortArr;
}