算法笔记六：使用分治策略执行快速排序

算法思想：

//采用分治策略，将原数组，分解为三部分：左边的 + 已最终定位的节点位置 + 右边的

//分解：取任意一个位置的数，将数组划分为3部分：左边+该数的最终位置+右边，继续对左右两边递归执行分解操作

//解决：求出给定位置数的最终位置，即保证左边都比它小，右边都比它大

//合并：在分解的过程中，就已经将元素的最终位置给计算好了，不需要任何操作

分解—>解决—>合并

在分解的步骤中，什么条件下是阻止其继续分解的终止阀呢？：

分解的只有一个元素了

解决：

找出给定元素应该在该数组出现的最终位置，这里只要做一次数组的遍历就可以计算出来了，具体实现方式请参见实现代码的注释部分

合并：

不需要执行任何动作，解决的过程中就已经将要解决的数子的位置给计算好了

最好情况：

O(n*log2n)

最坏情况：

O(n^2)

下面我们来分析下这里的时间代价：

假设数组是一个已经排好序的数组，那么在分解的过程中，每个元素的初始化位置就是其最终位置，则如果每次选择数组中的第一个元素执行分解的话，那么就会导致每次都分解成只有右边一侧的子数组，而由于每次解决的代价都是数组大小n，则总的代价为：n + (n-1) + (n-2) + … + 1 = O(n^2)

如果每次分解都能将数组分割为两部分(假定为平均的2个部分，有利于分析)，则有：

T(n) = T(n/2) + T(n/2) + O(n)

使用带入法：

T(n) = T(n/4) + T(n/4)+ T(n/4)+ T(n/4) + O(n)  + O(n/2)

使用递归树的分析不难得出：T(n) =  O(n*lgn)

这里需要理解的是，即使是每次分解后的数组不是均衡的，比如左边是9/10，右边是1/10，依然不影响这个这个递归树的高度，所以无论是否均衡，其代价都是O(n*lgn)，而如果每次分解后只产生一颗子树，那么树的高度将大大增加，导致的时间代价就是上面分析的最坏情况n^2

空间代价上，只是两个元素交换时需要开辟一个元素的额外空间，基本忽略不计！

算法实现：

//
//  QuickSort.h
//  p1
//
//  Created by MinerGuo on 14-10-17.
//  Copyright (c) 2014年 MinerGuo. All rights reserved.
//

#ifndef __p1__QuickSort__
#define __p1__QuickSort__

#include <stdio.h>


//采用分治策略，将原数组，分解为三部分：左边的 + 已最终定位的节点位置 + 右边的

//分解：取任意一个位置的数，将数组划分为3部分：左边+该数的最终位置+右边，继续对左右两边递归执行分解操作

//解决：求出给定位置数的最终位置，即保证左边都比它小，右边都比它大

//合并：在分解的过程中，就已经将元素的最终位置给计算好了，不需要任何操作
class QuickSort {
    void changeTwoItems(int * data,int i,int j){
        int tmp = *(data + i);
        *(data + i) = *(data + j);
        *(data + j) = tmp;
    }
    
public:
    
    //分解
    void split(int * data,int left,int right){
        //只有一个元素时终止
        if(left >= right){
            return;
        }
        //这里选取参考数组的位置是可以随机的
        int referenceDataPosition = left;
        //解决
        int finalPosition = solve(data,left,right,referenceDataPosition);
        //fianlPosition 元素已经定位完毕
        //分解左半部分
        split(data,left,finalPosition -1);
        //分解右半部分
        split(data,finalPosition + 1,right);
    }

    //给定数组的区间，以及要找出数组最终位置的那个数据
    //返回该数据的最终位置，
    //这里的方法是：先从后往前找，发现第一个比它小的，调换，从前往后找，这样保证了后面都比他大
    //然后从前往后找，找到第一个大于等于它的，调换，再从后往前找，直到左右相等
    int solve(int * data,int left,int right,int referenceDataPosition){
        int finalDataPosition = referenceDataPosition;
        int referencDataValue = *(data + referenceDataPosition);
        
        int lp = left,rp=right,direction = -1;
        while(lp < rp){
            if(direction == -1){
                //从后往前
                for(;rp>=lp;rp--){
                    if(*(data + rp) < referencDataValue){
                        changeTwoItems(data,rp,finalDataPosition);
                        finalDataPosition = rp;
                        direction = 1;
                        break;
                    }
                }
            }else{
                //从前往后
                for(;lp<=rp;lp++){
                    if(*(data + lp) >= referencDataValue){
                        changeTwoItems(data,lp,finalDataPosition);
                        finalDataPosition = lp;
                        direction = -1;
                        break;
                    }
                }
            }
        }
        
        return finalDataPosition;
    }
    
    
    //排序入口
    void do_sorting(int * data,int size){
        split(data, 0, size - 1);
    }
    
};

#endif /* defined(__p1__QuickSort__) */

算法总结：

由于一般待排序的记录都是无序的，所以该算法很少会出现最坏情况，又因为其无论是在时间代价上和空间代价上，其解都是最优的，所以其广泛的运用于各种排序算法中