从荷兰国旗问题到随机快速排序

1. 荷兰国旗问题

现有红白蓝三个不同颜色的小球，乱序排列在一起，请重新排列这些小球，使得红白蓝三色的同颜色的球在一起。这个问题之所以叫荷兰国旗问题，是因为我们可以将红白蓝三色小球想象成条状物，有序排列后正好组成荷兰国旗。

2. 荷兰国旗解

具体的问题可以参考【算法习作】荷兰国旗问题,个人感觉讲的还是蛮清楚的, 这里的函数partitionQucikSort问题的解，这里返回值我们返回的是给定targetNum 相等的元素的下标，包含坐下标index[0],右部分index[1]。其中部分都是< targetNum, index[0]~index[1]之间都是==targetNum,>index[1]部分都是>targetum。

C++代码：

#include 
#include 
#include 
#include 

template<typename T>
void swapNumers(std::vector<T>& vec, int i, int j) {
    T temp = vec[i];
    vec[i] = vec[j];
    vec[j] = temp;
}

template<typename T>
std::vector<T> partitionQucikSort(std::vector<T>& vec, int start, int end, int targetNum) {
    assert(end > start);
    int less = start - 1;
    int more = end + 1;
    while (start < more) {
        if (vec[start] < targetNum) {
            swapNumers(vec, ++less, start++);
        } else if (vec[start] > targetNum) {
            swapNumers(vec, --more, start); // start don't move
        } else {
            start++;
        }
    }

    return {less + 1, more - 1};
}

template<typename T>
void generateRandomVector(std::vector<T>& vec, int num) {
    srand((unsigned int)time(nullptr));
    for (int i = 0; i < num; ++i) {
        vec[i] = rand() % 10 + 1;   // generate random numbers in [1, 10]
    }
}

template<typename T>
void display(std::vector<T>& vec) {
    if (vec.size() < 1) {
        return;
    }
    for (auto it : vec) {
        std::cout << it << ", ";
    }
    std::cout << "\n";
}
int main() {
    std::vector<int> vec(10, -1);
//    std::vector vec{6, 8, 1, 9, 9, 2, 9, 6, 5, 2};
    generateRandomVector(vec, 10);
    display(vec);//
    std::vector<int> partitionSort = partitionQucikSort(vec, 0, vec.size() - 1, 6);
    display(vec);
    for (auto it : partitionSort) {
        std::cout << it << ',' << std::endl;
    }
//    return 0;
}

小插曲：

在写荷兰国旗问题的时候， 一开始一直没有得到正确的下标，奈何只能一步步调试，一开始我的函数swapNumers是这么定义的：

template<typename T>
void swapNumers(std::vector<T>& vec, int i, int j) {
    vec[i] = vec[i] + vec[j];
    vec[j] = vec[i] - vec[j];
    vec[i] = vec[i] - vec[j];
}

但是后面经过调试发现， 如果我们假设让其自身交换也就是swapNumers(vec, 0, 0)，假设我们这里的vec={1, 2}。那么你猜最后的结果是什么？这里也不卖关子了，最后竟然调试发现结果为0，而不是我们想当然的认为自身和自身交换不变。所以这里也是有点疑惑，如果知道的小伙伴可以给我留言这是为什么。所以后面的话我也是使用最传统的方法进行交换二个数据，使用临时变量temp。

3. 随机快速排序

其实我们已经得到了荷兰国旗的解了，然后的话我们快速排序的方法就是分治的思想。最原始的快速排序算法选取给定数组最后一个元素作为荷兰国旗targetNum,然后通过荷兰国旗的解，我们可以把数组分成三个部分，然后对小于和大于targetNum部分再次调用荷兰国旗的解，这样我们就可以求解快速排序了。但是这样也会出现一个问题，就是我们是利用给定数组最后一个元素，现在有这样一种情况，假设我们数组已经正序或者反序的话，这时候的快排复杂度还是$O(N)$,所以的话我们可以随机选择一个数，而不是选择最后一个数，这样的话我们得到的复杂度就是一种概率，这样我们就从原始的快速排序过渡到随机快速排序。与此同时，随机快速排序的每次都需要我们记录一下等于给定targetNum的下标，可以这样理解，每次的话我们都是“获取”下标，这样的话平均复杂度就$O(lo{g}_{2}N)$。 为了利用我们之前说的对数器，这里我们也把用起来。

参考：快速排序和随机快速排序

C++代码：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

template<typename T>
void swapNumers(std::vector<T>& vec, int i, int j) {
    T temp = vec[i];
    vec[i] = vec[j];
    vec[j] = temp;
}

template<typename T>
bool compare(T a, T b) {
    return a < b;
}

template<typename T>
void rightMethod(std::vector<T>& vec) {
    sort(vec.begin(), vec.end(), compare<T>);
}

template<typename T>
std::vector<T> partitionQucikSort(std::vector<T>& vec, int start, int end) {
    assert(end > start);
    int less = start - 1;
    int more = end;
    while (start < more) {
        if (vec[start] < vec[end]) {
            swapNumers(vec, ++less, start++);
        } else if (vec[start] > vec[end]) {
            swapNumers(vec, --more, start); // start don't move
        } else {
            start++;
        }
    }
    swapNumers(vec, more, end); // attention! we need to exange

    return {less + 1, more};  // new solutions
}
template<typename T>
void quickSortPartition(std::vector<T>& vec, int start, int end) {
    if (start < end) {
        srand((unsigned int)time(nullptr));
        swapNumers(vec, rand() % (end - start + 1) + start, end);   // random quciksort
        std::vector<T> index  = partitionQucikSort(vec, start, end);
        quickSortPartition(vec, start, index[0] - 1);   //
        quickSortPartition(vec, index[1] + 1, end);
        std::vector<T> ().swap(index);
    }
}
template<typename T>
void quickSort(std::vector<T>& vec) {
    if (vec.size() < 2) {
        return;
    }
    int start = 0;
    int end = vec.size() - 1;
    quickSortPartition(vec, start, end);
}

template<typename T>
void generateRandomVector(std::vector<T>& vec, int maxSize, int minValue, int maxValue) {
    assert(maxValue > minValue);
    srand((unsigned int)time(nullptr));
    int size = rand() % maxSize + 1;
    vec = std::vector<T> (size, -1);
    for (int i = 0; i < size; ++i) {
        vec[i] = (rand() % (maxValue - minValue)) + minValue + 1;
    }
    return;
}
template<typename T>
bool isEqual(std::vector<T>& vec1, std::vector<T>& vec2) {
    int size1 = vec1.size();
    int size2 = vec2.size();
    if (size1 != size2) {
        return false;
    } else {
        return equal(vec1.begin(), vec1.end(), vec2.begin());
    }
    return true;
}
template<typename T>
void copyVector(std::vector<T>& vec1, std::vector<T>& vec2) {
    if (vec2.size() < 1) {
        return;
    }
    vec1 = std::vector<T> (vec2.size(), -1);    // this is very imporpant!
    for (int i = 0; i < vec2.size(); ++i) {
        vec1[i] = vec2[i];  // attention initial
    }
    // also we can use vec1 = vec2;
}
template<typename T>
void inputVector(std::vector<T>& vec) {
    T data;
    std::cin >> data;
    vec.push_back(data);
    while (std::cin.get() != '\n') {
        std::cin >> data;
        vec.push_back(data);
    }
}
template<typename T>
void display(std::vector<T>& vec) {
    for (auto it: vec) {
        std::cout << it << ',';
    }
    std::cout << "\n";
}
template<typename T>
void testAlgorithm(void (*pTestAlgorithm) (std::vector<T>&)) {
    int testEpoch(100000);
    int maxSize(100);
    int minValue(-100);
    int maxValue(100);
    bool successFlag(true);
    std::clock_t  startTime, endTime;
    startTime = std::clock();
    for (int i = 0; i < testEpoch; ++i) {
        std::vector<T> v1, v2, v3;
        generateRandomVector(v1, maxSize, minValue, maxValue);
        copyVector(v2, v1);
        copyVector(v3, v1);
        rightMethod(v1);
        pTestAlgorithm(v2);
        if (!isEqual(v1, v2)) {
            successFlag = false;
            display(v3);
            break;
        }
        std::vector<T> ().swap(v1);
        std::vector<T> ().swap(v2);
        std::vector<T> ().swap(v3);
    }
    if (successFlag) {
        std::cout << "nice!" << std::endl;
    } else {
        std::cout << "something wrong" << std::endl;
    }
    endTime = std::clock();
    std::cout << "Total usage time is: " << (endTime - startTime) / double(CLOCKS_PER_SEC) << 's' << std::endl;
}
int main() {
    testAlgorithm(quickSort<int>);
//    std::vector vec;
//    inputVector(vec);
//    display(vec);
//    std::cout << "random quick sort:" << std::endl;
//    quickSort(vec);
//    std::vector index = partitionQucikSort(vec, 0, vec.size() - 1);
//    display(vec);
//    std::cout << index[0] << " " << index[1] << std::endl;
    return 0;
}

写快排的时候一开始出现错误，没办法只能一个函数模块的调试，最后定位到错误的是：如果一个vec2给另一个vec1赋值的时候，那么可以直接使用vec1 = vec2, 但是如果通过遍历的方法的话，一定需要首先给vec1[i]先初始化操作，然后再去执行vec1[i] = vec2[i]才可以啦！