分治思想在查询中的应用

 分治法是算法设计方法的一种，它通过将问题划分为规模更小的子问题，递归的解决划分后的子问题，再将结果合并从而高效的解决问题。下面通过简单的寻找数组中最大最小值问题，认识到分治思想的优秀之处。

对于寻找数组中最大最小值问题，简单的扫描，需要两遍确定min，max，即复杂度为2*N

奇偶位排序： 经历N/2 次比较，讲较大的数放到奇数位子，较小数放到偶数位置，最后通过N次比较获取min以及max；

int evenfind(int *array, int count) 
{ 
    if(array == NULL) 
        return -1; 
    for(int i =0; i< count; i+=2) 
    { 
        //replace,so the bigger put first 
        if(array[i] > array[i+1]) 
        { 
            int temp = array[i+1]; 
            array[i+1] = array[i]; 
            array[i] = temp; 
        } 
    } 
    int max =0; 
    for(int i=1; i<count; i+=2) 
    { 
        if(max < array[i]) 
            max = array[i]; 
    } 
    return max; 
}

折半查找：分别求出前后N/2个数的min 和 max，然后取较小的min，较大的为max。递归执行过程，先走到可以分的最左边，然后往右边，这样一个最小单元left+right走完，往left+right 的右边拥有同样大小部分，这时把到该部分分为left ，right，完成left+right。依次循环。

比如1,2,3,45,6,7,8 第一次分为 left 1234，right 5,6,7,8. 第二次分为left 1，2 right 3，4； 第三次分为left 1,right 2；

 不可分，比较得到返回2，在比较 left 3，right4，返回4， 再比较left 2和 right 4，返回4,；

然后依次比较5,6返回6，比较7,8返回8；

最后比较4和8 返回8；

int search(int *array, int begin , int end) 
{ 
    if(end - begin <=1) 
    { 
        if(array[end] < array[begin]) 
            return array[begin]; 
        else 
            return array[end]; 
    }
    int maxLeft=0, maxRight=0; 
    maxLeft = search(array, begin, begin + (end - begin) /2); //一直分到最左边，return max
    maxRight = search(array,begin + (end - begin)/2, end); //然后走右边，return max
    if(maxLeft > maxRight) 
        return maxLeft; 
    else 
    { 
        return maxRight; 
    } 
}

关于折半查找复杂度分析如下。

             

              

快速排序：快速排序使用了分治的思想，最坏情况下复杂度为 N*N， 但是平均性能非常好，期望时间复杂度是 n*logn（即对原数列每次分开后形成类似完全二叉树，层数为logn，而每层的比较次数均为n，故为n*logn），另外还可以原址排序。

bool QuickSort(int *array,int begin, int end) 
{ 
    if(begin < end) 
    { 
        //取第一个数据出来，作为比较对照
        int temp = array[begin]; 
        int i = begin; 
        int j = end; 
        while(i < j) 
        { 
            while(i < j && array[j]> temp)  //从尾往前找到第一个大于的值
                j--; 
            if(i<j) 
            { 
                array[i] = array[j];       //把这个值放到之前已经被取出来值的地方i，在j处形成空缺
                i++; 
            } 
            while (i<j && array[i]< temp) //顺序找到第一个小于参考值
                i++; 
            if(i<j) 
            { 
                array[j] = array[i];     //把这个值填到前面形成空缺处 j，i处继续形成空缺
                j--; 
            } 
        } 
        array[i] = temp;   //循环过后，紧接前面i处空缺，填上最开始的参照值
         
        int l = i; 
        //http://blog.csdn.net/morewindows/article/details/6684558 
        QuickSort(array,begin, l-1); 
        QuickSort(array, l+1, end); 
        return true; 
    } 
    else 
    { 
        return false; 
    } 
}

桶排序：桶排序是复杂度 为N，或接近N 排序算法，适合数据分布均匀的排序；思想是分配适当个数的桶，再桶中对数据进行插入排序。桶排序并不是分治思想的应用，但是这种把数据按基数分放到桶中，对桶中数据插入排序，也是分开处理吧。

void doinsertionsortforbucket(int* input, int len) 
{ 
    while( len-- > 0) { 
        if (input[len] > input[len+1]) { 
            int tmp = input[len]; 
            input[len] = input[len+1]; 
            input[len+1] = tmp; 
        } else 
            return; 
    } 
}
void bucketsort(int* input) 
{ 
    queue<int> *buckets[BUCKET_K]; 
    for ( int i = 0; i < BUCKET_K; i++ ) 
        buckets[i] = new queue<int>;
    // Hash the input and insert the content into appropriate bucket based on hash. 
    for (int i=0;i<INPUT_SIZE;i++) 
    { 
        int hashValue = Hash(input[i]); 
        if (hashValue >= BUCKET_K) 
            hashValue = BUCKET_K-1;
        buckets[hashValue]->push(input[i]); 
    }
    // extract the content from each of the buckets in order. 
    // using insertion sort 
    int outputidx = 0; 
    for ( int i = 0; i < BUCKET_K; i++ ) 
    { 
        if (buckets[i]->size() == 1) { 
            input[outputidx++] = buckets[i]->front(); 
            cout << buckets[i]->front() << " | "; 
            buckets[i]->pop(); 
        } 
        if (buckets[i]->size() > 1) 
        { 
            while (!buckets[i]->empty()) 
            { 
                input[outputidx] = buckets[i]->front(); 
                doinsertionsortforbucket(input, outputidx); 
                cout << buckets[i]->front() << " "; 
                buckets[i]->pop(); 
                outputidx++; 
            } 
            cout << "| "; 
        } 
    } 
    // clear buckets. 
    for ( int i = 0; i < BUCKET_K; i++ ) 
        delete buckets[i];
}

总结： 分治思想应用了排序的位置信息，形成线性或树形结构，分开进行比较，不用每次都从头到尾重复某些比较，达到优化时间复杂度的目的。

参考

www.geeksforgeeks.org/bucket-sort-2/

www.sourcetricks.com/2013/03/bucket-sort.html#.VdnXmfmqpBc

blog.sina.com.cn/s/blog_614316190100ei83.html

blog.csdn.net/morewindows/article/details/6684558