重学数据结构——快速排序，二分法查找

每次提起快排，内心中都有点隐隐作痛。

当时腾讯的那个面试官让我写快排的前两遍排序结果，结果，我当时居然没写上来……

这个，就是所谓的关键时刻掉链子吧，这么经典的快排都不会，真是丢死人了……

今天在实验室的时候我第三次不借助任何资料，根据快排思想，写出了快排的程序~

先看看我第二次的那篇文章，第一次完成的已经不知道被我丢哪里去了~

void qsort(int * array, int length)
{
    if(length <= 1)
        return;
    int i = 0,j = length - 1;
    int Addr = 0;
    int KeyWord = array[0];//the first number to be sort
    while(i < j)
    {
        while(array[j] >= KeyWord && j > i)
            -- j;
        swap(array[j], array[i]);
        while(array[i] <= KeyWord && j > i)
            ++ i;
        swap(array[i], array[j]);
    }
    qsort(array, i);
    qsort(&array[i] + 1, length - i - 1);
}

再看看我第二次写的代码，也就是今天写的。

void qsort(int * parray, int size)
{
    if(size <= 1)
        return;
    int npLocal = 0;
    int npCmp = size - 1;
    while(npLocal < npCmp)
    {
        for(;npCmp > npLocal;-- npCmp)
        {
            if(parray[npCmp] >= parray[npLocal])
                continue;
            else
                break;
        }
        swap(parray[npCmp], parray[npLocal]);
        //swap之后，npCpm和npLocal指向相反
        for(;npLocal < npCmp;npLocal ++)
        {
            if(parray[npLocal] <= parray[npCmp])
                continue;
            else
                break;
        }
        swap(parray[npCmp], parray[npLocal]);
    }
    qsort(parray, npLocal);
    qsort(parray + npLocal + 1, size - npLocal - 1);
}

比较之后，感觉，两段代码貌似差别不大，结构和递归形式基本一致。我觉得还是因为今天的代码收到了以前的影响吧，不过这个结构我觉得还可以，至少看着还是挺明朗的。

在写代码之前，我的习惯基本就是，先拿出笔和纸，写一写，弄清楚步骤，至少在写代码之前，要自己明白具体是怎么一回事。

我认为在还没有明白算法的情况下就开始写代码，是很低效的。谋而后动，效率肯定会更高。

快排之所以这么重要，我觉得主要还是因为其非凡的速度。

举个例子：排10w个整数的时候，我的计算机用选择排序和起泡法排序的速度基本都是在32秒左右，单线程。

而改用快排之后，时间好像在0.5秒以内。这个速度还是包含了10w个数的rand函数初始化的。

这个速度简直就是无与伦比~我是很佩服的。

接下来看今天写的另外一个算法：二分查找

二分查找也是因为效率了。对于一个已排序的线性队列使用二分法查找，最慢次数为log2N，可以说是最快的查找方式之一了。

当然了，如果是双线程，就更快了。

接着看代码：

int bSearch(int * parray, int size, const int objval)
{
    if(size <= 1)
        return 0;
    int start = 0;
    int mid = size / 2;
    int end = size - 1;
    while(objval != parray[mid])
    {
        if(mid == end)
        {
            if(objval == parray[start])
                return start;
            else
                return -1;
        }
        if(mid == start)
        {
            if(objval == parray[end])
                return end;
            else
                return -1;
        }
        if(objval > parray[mid])
        {
            start = mid;
            mid += (end - start) / 2;
        }
        else
        {
            end = mid;
            mid -= (end - start) / 2;
        }
    }
    return mid;
}

代码中使用了三个变量：start mid end三个变量来进行区间划分，效果还挺不错的。

其中，在边界上，会出现两种情况：start == mid 以及mid == end的情况。这个情况的出现，是因为当end - start == 1的时候，就会出现1 / 2 == 0的情况，此时mid的值是无法更新的。所以要对这种情况专门进行处理，所有就出现了代码中循环语句最上面的两个if比较了。

今天在写着两个算法的时候，都出现了走歪路的情况，不过，觉得，还是挺有意义的。

其实二分法还有一个不错的设想，就是用单地址根据比较结果进行增减，来比较值，但是因为会出现有空缺值无法访问的情况，所以放弃了那种形式，但思想还是不错的。

就到这啦，最近是要重学数据结构的，原因很简单：这东西长时间不设计，肯定会忘~