剑指Offer-快速排序

目录

• 基本思想
• 剑指Offer上的Partition实现
• 一般教材上的Partition实现
• 总结

剑指Offer上的快速排序的Partition函数与我在数据结构书上学到的不一样，因此就想要探索下这两种不同的处理方式。

基本思想

快速排序的基本思想是基于分治法。在待排序表L[1...n]中任取一个元素pivot作为基准，通过一趟排序将待排序表划分为独立的两部分L[1...k-1]和L[k+1...n]，使得L[1...k-1]中所有元素小于pivot，L[k+1...n]中所有元素大于或等于pivot，则pivot放在了其最终位置L(k)上。而后递归地对两个子表重复上述过程，直至每部分内只有一个元素或空为止，即所有元素放在了其最终位置上。

剑指Offer上的Partition实现

// Partition为分割函数, length表示data数组的长度
int Partition(int data[], int length, int low, int high) {
    if (data == nullptr || length <= 0 || low < 0 || high >= length) {
        return 1;
    }

    // 在[low, high]区间中随机取一个基准值，并将其换到区间最末尾
    int index = RandomInRange(low, high);
    Swap(&data[index], &data[high]);

    // small在low的前面一位
    int small = low - 1;

    for (index = low; index < high; ++index) {
        if (data[index] < data[high]) {
            // ++small后表示大于基准值的第一个数的下标
            // 如果不存在大于基准值的数，则表示当前比较的数字下标
            ++small;

            // 交换后的small表示小于基准值的最后一个数字的下标
            if (small != index) {
                Swap(&data[index], &data[small]);
            }
        }
    }

    // ++small后表示大于基准值的第一个数的下标
    ++small;
    Swap(&data[small], &data[high]);

    return small;

}

快速排序其它函数实现如下:

// 生成一个随机数，范围在[low，high)，是一个前闭后开的区间
int RandomInRange(int low, int high) {
    return rand() % (high - low) + low;
}

// 交换两个整数
void Swap(int* left, int* right) {
    int temp  = *left;
    *left = *right;
    *right = temp;
}

// 快速排序函数
void QuickSort(int data[], int length, int low, int high) {
    if (low == high) {
        return;
    }

    int index = Partition(data, length, low, high);

    if (index > low) {
        QuickSort(data, length, low, index - 1);
    }

    if (index < high) {
        QuickSort(data, length, index + 1, high);
    }
}

// 数据打印
void PrintData(int data[], int length) {
    for (int i = 0; i < length; ++i) {
        std::cout << data[i] << " ";
    }

    std::cout << std::endl;
}

int main() {
    // 以系统时间作为随机函数种子
    srand((unsigned)time(nullptr));

    int const length = 10;

    int data[length];

    // 生成随机数
    for (int i = 0; i < length; ++i) {
        data[i] = RandomInRange(1, length*length);
    }

    // 打印生成的随机数
    PrintData(data, length);

    // 调用快排函数进行排序
    QuickSort(data, length, 0, length - 1);

    // 打印快速排序后的数
    PrintData(data, length);

    return 0;

}

初始顺序为{49, 38, 65, 97, 76, 13, 27}，基准值为49的数据的第一趟快速排序的实现如下所示：

步骤	small	index
0			49	38	65	97	76	13	27
1			27	38	65	97	76	13	49
2	0	0	27	38	65	97	76	13	49
3	1	1	27	38	65	97	76	13	49
4	1	2	27	38	65	97	76	13	49
5	1	3	27	38	65	97	76	13	49
6	1	4	27	38	65	97	76	13	49
7	2	5	27	38	13	97	76	65	49
8	3	6	27	38	13	49	76	65	97

第一趟排序完之后基准值49之前的{27, 38, 13}都比49小，基准值49之后的{76, 65, 97}都比49大。

一般教材上的Partition实现

// Partition为分割函数
int Partition(int data[], int low, int high) {

    // 将当前表中第一个元素设为基准值，对表进行划分
    int pivot = data[low]; 

    // 循环跳出条件
    while (low < high) {
        while (low < high && data[high] >= pivot) {
            --high;
        }

        // 将比基准值小的元素移动到左端
        data[low] = data[high];

        while (low < high && data[low] <= pivot) {
            ++low;
        }

        // 将比基准值大的元素移动到右端
        data[high] = data[low];
    }

    // 基准元素存放到最终位置
    data[low] = pivot;

    // 返回存放基准值的最终位置
    return low;
}

快速排序其它函数实现如下:

void QuickSort(int data[], int low, int high) {
    // 递归跳出条件
    if (low < high) {
        // 将data[low...high]一分为二，pivotpos是基准值
        int pivotpos = Partition(data, low, high);

        // 对左子表进行递归排序
        QuickSort(data, low, pivotpos - 1);

        // 对右子表进行递归排序
        QuickSort(data, pivotpos + 1, high);
    }
}

初始顺序为{49, 38, 65, 97, 76, 13, 27}，基准值为49的数据的第一趟快速排序的实现如下所示：

步骤	low	high
0	0	6	49	38	65	97	76	13	27
1	2	6	27	38	65	97	76	13	27
2	2	6	27	38	65	97	76	13	65
3	2	5	27	38	13	97	76	13	65
4	3	5	27	38	13	97	76	97	65
5	3	3	27	38	13	49	76	97	65

第一趟排序完之后基准值49之前的{27, 38, 13}都比49小，基准值49之后的{76, 97, 65}都比49大。

总结

可以看出，上述这两种思想导致的运行过程是不同的，前者是用small指代小于标准元素的最右位置，在遍历过程中进行交换操作来保证small左边都是小于标准元素的元素，而后者是用low，high分别表示小于和大于基准值的集合边界位置，所以后者更浅显易懂。

---

个人主页：

www.codeapes.cn