《啊哈算法》第一章 排序

参考：《啊哈算法》
嗯，抄代码的意义在于你能不能抄正确！
嗯，我又开始了新的学习，任务没有完成哪里还有时间吃饭？不逼逼自己不知道自己的潜力究竟有多大！
从网上看到这本书用于算法入门时不错的，买了很多书，顺便就带了一本。拿回来就看了50页。因为前面实在是太基础了。（其实算法是我的硬伤，算法导论实在是看不懂）

1，第一章上来就是一个弱化版的桶排序，嗯，上一学期的数据结构课学了那么多的排序还是没有听说过，直到上一次舍友提起过。
准确地说我通过这个例子着实是学会了打表。
先来个简单0-10的排序

#include<iostream>
using namespace std;
const int N=10;
int a[N]= {0};
int book[N]= {0};
int main() {
    int T;
    cin>>T;
    for(int i=0; i<T; i++) {
        cin>>a[i];
        book[a[i]]++;//打表
    }
    for(int i=0; i<10; i++) {//这个顺序很重要，就是输出的排列大小顺序
        if(book[i]) {
            for(int j=1; j<=book[i]; j++) {
                cout<<i<<ends;
            }
        }
    }
    cout<<endl;
    return 0;
}

下面扩展成0——1000范围内的排序

#include<iostream>
#include <cstring>
using namespace std;
const int N=1000;
int a[N]= {0};
int book[N]= {0};
int main() {
    int T;
    while(cin>>T) {
        memset(a,0,sizeof(a));
        memset(book,0,sizeof(book));
        for(int i=0; i<T; i++) {
            cin>>a[i];
            book[a[i]]++;
        }
        for(int i=0; i<N; i++) {
            if(book[i]) {
                for(int j=0; j<book[i]; j++) {
                    cout<<i<<ends;
                }
            }
        }
        cout<<endl;
    }

    return 0;
}

注意一点是memset()函数在文件string中

桶排序（简化版）的优点是非常容易理解，时间复杂度是O(M+N)，但是你比较数的大小范围决定了空间大小，空间实在是有点浪费！

2，冒泡排序

嗯，没错也是很基础的冒泡排序，C语言如果大家是看的谭叔的书的话一定会回忆起一些咬笔头的日子。这本书对冒泡的解释再也没有谁了！
基本思想：比较相邻的两个元素的大小，如果位置不对则进行交换。

简单的

#include<iostream>
using namespace std;
const int N=10;
int a[N];
int main()
{
    int T;
    cin>>T;
    for(int i=0;i<T;i++){
        cin>>a[i];
    }
    for(int i=0;i<T-1;i++){//注意这两个循环条件，第一个是数字总是减一，是代表总的比较趟数
        for(int j=i;j<T-1-i;j++){//每一躺的比较次数，随着比较趟数的增加而减小，每次带入i=0，测试，末尾是不是为T-2，因为第一躺要比较T-1次，下标最大到T-2，因为还要+1
            if(a[j]>=a[j+1]){
                swap(a[j],a[j+1]);
            }
        }
    }
    for(int i=0;i<T;i++){
        cout<<a[i]<<ends;
    }
    cout<<endl;
    return 0;
}

嗯，能够根据输入的数目数，直接进行比较，不用开数组，真是方便，但是一看复杂度，嗯，O（N^2）比较虐心。

时间上的大区别：假如我们的计算机一秒可以运行10亿次，那么对一亿个数进行排序，桶排序只需要0.1秒，而冒泡则要1千万秒，达十五天之久！（啊哈原话）

3，嗯，要么浪费时间，要么浪费空间，下面就是快排表演的时候了。
关键词，基准数，哨兵。二分思想（因此肯定要用递归）

简单快排

#include<iostream>
#include <cstring>
using namespace std;
int a[101],n;
/*二分，找中点，先右边哨兵向左移动，寻找比基准数小的，找到后就停下
再使左哨兵往右移动，找比基准数大的，找到后停下，这时与右哨兵交换信息，重复上述操作。
知道哨兵们相遇，注意特殊情况是，有可能哨兵在移动的过程中就碰面了，这个时候结束
（还有就是基准数一般选最左边的第一个数，对应右边哨兵先走。
*/
void quicksort(int left,int right) {
    int i,j,temp=a[left];//i为左边哨兵，j为右边哨兵，temp临时变量
    if(left>right) { //健壮性
        return ;
    }
    //确定基准数
    i=left;
    j=right;//哨兵已经准备
    while(i!=j) {
        while(a[j]>=temp&&i<j) { //右哨兵向左移动，满足条件则移动，不满足退出
            j--;
        }
        while(a[i]<=temp&&i<j) { //左哨兵向右移动，满足条件则移动，不满足退出
            i++;
        }
        if(i<j) { //当哨兵停下时他们并不相遇，交换信息
            swap(a[i],a[j]);
        }
    }

//上一个循环的作用就是使i=j，使哨兵们相遇，相遇就要归位。基数归位，归位的意思是使基准数到应该去的地方
    swap(a[left],a[i]);
    if(i<j) { //当哨兵停下时他们并不相遇，交换信息
        swap(a[i],a[j]);
    }
//这里简直和二分是一模一样的
    quicksort(left,i-1);//前半部分
    quicksort(i+1,right);//后半部分，刚好漏掉已经归位的数字
    return ;
}
int main() {
    int T;
    while(cin>>T) {
        memset(a,0,sizeof(a));
        for(int i=0; i<T; i++) {
            cin>>a[i];
        }
        quicksort(0,T-1);
        for(int i=0; i<T; i++) {
            cout<<a[i]<<ends;
        }
        cout<<endl;
    }
    return 0;
}

嗯，基本知识点就是这些了，回顾一下三种排序算法的时间复杂度：
桶排序最快，O（M+N)
冒泡是O（N^2)
快排是O（N*logN)(快排在有序序列的条件下排序是最费时间的）