c++ stl 好用的算法函数 -01 partition

stl 好用函数

前言

partition 是一种非常好用的编程思想， 比如，我们需要找到一堆数里面的符合要求的所有数，并将所有的数分成两堆，前面的符合要求，后面的不符合要求， 比如找到所有的偶数， 所有的的素数等等， 我们想介绍函数的用法，最后再，再来详解代码的实现

1、分两堆，前面是偶数，后面是其他

	#include <iostream>
#include <utility>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>
#include <random>

using namespace std;

///   工具函数, 随机生成
vector<int> get_random_vec_int(int n, int limit) {
    auto seed = std::chrono::system_clock::now().time_since_epoch().count();
    default_random_engine e(seed);
    uniform_int_distribution<int> un;
    vector<int> data(n);
    for (int i = 0; i < n; ++i) {
        data[i] = un(e) % limit;
    }
    return data;
}

void print(vector<int> &data, string title, int start, int end) {
    cout << title;
    for (int i = start; i < end; ++i) {
        cout << data[i] << "\t";
    }
    cout << endl;
}




/*
 *  partition 参数介绍
 *  1. begin迭代器
 *  2. end 迭代器 注意是前开后闭的 [begin, end)
 *  3. pred 是个 callable 类型, 签名如 bool(int v);
 *     partition的返回值q指向第一个不满足 pred 的位置,
 *     最终[begin, q) 符合pred, [q, end) 不符合
 * */
int partition_all_event(vector<int> &data) {
    int q = partition(data.begin(), data.end(), [&](int v) {
        return v % 2 == 0;
    }) - data.begin();
    return q;
}

int main() {
    auto vec = get_random_vec_int(10, 100);

    print(vec, "source: ", 0, vec.size());
    
    int q = partition_all_event(vec);
    
    print(vec, "event: ", 0, q);
    
    print(vec, "other: ", q, vec.size());
}

输出

---

一、patition 源码

源码

/*
 *  源码, 为了区分, 使用Partition这个名字
 * */
template<class _Predicate, class _BidirectionalIterator>
_BidirectionalIterator
Partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
          bidirectional_iterator_tag = bidirectional_iterator_tag{}) {
    while (true) {
        while (true) {
            if (__first == __last) {
                return __first;
            }
            if (!__pred(*__first)) {
                break;
            }
            ++__first;
        }
        do {
            if (__first == --__last) {
                return __first;
            }
        } while (!__pred(*__last));
        swap(*__first, *__last);
        ++__first;
    }
}

翻译一下源码

// [0, begin) 符合pred
// [end, sz) 不符合pred
// [begin, end) 待求区域
// 经过每一次改变后上升循环不变式成立
// 最终返回的是第一个不符合 pred位置
int my_partition(vector<int> &data, int begin, int end, const function<bool(int)> &pred) {
    for (;;) {
        for (;;) {
            if (begin == end) {
                return begin;
            }
            // 从前往后找第一个不符合的点
            if (!pred(data[begin])) {
                break;
            }
            ++begin;
        }
        // 从后往前找第一个符合的点
        do {
            if (begin == --end) {
                return begin;
            }
        } while (!pred(data[end]));
        swap(data[begin], data[end]);
        ++begin;
    }
    return begin;
}

另外一种实现方式

* [0, q) 符合
 * [q, begin) 不符合区域
 * [end, sz) 不符合
 * [begin, end) 待操作区域
 *
 *  循环不变式
 *
 * */
int my_partition2(vector<int> &data, int begin, int end, const function<bool(int, int)> &pred) {
    if (begin + 1 >= end) {
        return begin;
    }
    int q = begin - 1;
    int v = data[--end];
    for (; begin < end; ++begin) {
        if (pred(data[begin], v)) {
            ++q;
            if (q != begin) {
                swap(data[q], data[begin]);
            }
        }
    }
    if (++q != end) {
        swap(data[q], data[end]);
    }
    return q;
}

闭区间的实现[low, high]

int partition(vector<int> &data, int low, int high) {
    //
    int pivot = data[low];
    for (; 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;
}

二、具体实战

1、 快排

代码如下（示例）：

#include <iostream>
#include <utility>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>
#include <random>

using namespace std;


/*
 *  源码, 为了区分, 使用Partition这个名字
 * */
template<class _Predicate, class _BidirectionalIterator>
_BidirectionalIterator
Partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
          bidirectional_iterator_tag = bidirectional_iterator_tag{}) {
    while (true) {
        while (true) {
            if (__first == __last) {
                return __first;
            }
            if (!__pred(*__first)) {
                break;
            }
            ++__first;
        }
        do {
            if (__first == --__last) {
                return __first;
            }
        } while (!__pred(*__last));
        swap(*__first, *__last);
        ++__first;
    }
}

// [0, begin) 符合pred
// [end, sz) 不符合pred
// [begin, end) 待求区域
// 经过每一次改变后上升循环不变式成立
// 最终返回的是第一个不符合 pred位置
int my_partition(vector<int> &data, int begin, int end, const function<bool(int)> &pred) {
    for (;;) {
        for (;;) {
            if (begin == end) {
                return begin;
            }
            // 从前往后找第一个不符合的点
            if (!pred(data[begin])) {
                break;
            }
            ++begin;
        }
        // 从后往前找第一个符合的点
        do {
            if (begin == --end) {
                return begin;
            }
        } while (!pred(data[end]));
        swap(data[begin], data[end]);
        ++begin;
    }
    return begin;
}

/* [0, q) 符合
 * [q, begin) 不符合区域
 * [end, sz) 不符合
 * [begin, end) 待操作区域
 *
 *  循环不变式
 *
 * */
int my_partition2(vector<int> &data, int begin, int end, const function<bool(int, int)> &pred) {
    if (begin + 1 >= end) {
        return begin;
    }
    int q = begin - 1;
    int v = data[--end];
    for (; begin < end; ++begin) {
        if (pred(data[begin], v)) {
            ++q;
            if (q != begin) {
                swap(data[q], data[begin]);
            }
        }
    }
    if (++q != end) {
        swap(data[q], data[end]);
    }
    return q;
}


#define def_my_partition

void quickSort(vector<int> &nums) {
    function<void(int, int)> _quick = [&](int start, int end) {
        if (start + 1 >= end) {
            return;
        }
#ifdef STL_Partition
        int cmpValue = nums[end - 1];
        auto q = partition(nums.begin() + start, nums.begin() + end, [&](int v) {
            return v < cmpValue;
        }) - nums.begin();
        swap(nums[q], nums[end - 1]);
#endif
#ifdef def_my_partition
        int cmp = nums[end - 1];
        int q = my_partition(nums, start, end, [&](int v) {
            return v < cmp;
        });
        swap(nums[q], nums[end - 1]);
#endif

#ifdef def_my_partition2
        int q = my_partition2(nums , start, end, less<int>{});
#endif
        _quick(q + 1, end);
        _quick(start, q);
    };
    _quick(0, nums.size());
}

int main() {
    vector<int> data;
    default_random_engine e(time(NULL));
    uniform_int_distribution<int> un;
    for (int i = 0; i < 1000; i++) {
        data.emplace_back(un(e) % 108899);
        //data.push_back(i);
    }
    quickSort(data);
    for (auto v : data) {
        cout << v << "\t";
    }
    cout << endl;
    cout << is_sorted(data.begin(), data.end());
    sort(data.begin(), data.end());
}

三向partition

// [low, left] < target
// [left + 1, right + 1] == target
// [right, high] > target
// 三向partition 一个区域分为三个
pair<int, int> three_direction_partition(vector<int> &ss, int low, int high) {
    int target = ss[high];
    // 循环不变式
    // 1 [low, left] 为 < target
    // 2 [right, high - 1] > target

    // 循环不变式
    // 1 [low, left] 为 < target
    // 2 (left, i) >= 区域
    // 3 [i, high - 1]待处理区域
    // 最终  [low, left] 为 < target， 【left + 1, high - 1】 >= target
    int left = low - 1;
    int i = low;
    for (; i < high; i++) {
        if (ss[i] < target) {
            ++left;
            swap(ss[i], ss[left]);
        }
    }
    // 循环不变式
    // 1 [right, high - 1] > 区域
    // 2 (j, high) 不符合区域
    // 3 (left, j] 待处理区域
    // 最终 [right, high - 1] > 区域，[left + 1, right - 1] == 区域 [low, left] 为 < target
    int right = high + 1;
    int j = high - 1;
    for (; j > left; j--) {
        if (ss[j] > target) {
            --right;
            swap(ss[j], ss[right]);
        }
    }

    return {left + 1, right - 1};
}

pair<int, int> three_direction_partition2(vector<int> &ss, int low, int high) {
    int target = ss[high];
    // 循环不变式
    // 1 [low, left] 为 < target
    // 2 [right, high - 1] > target

    // 循环不变式
    // 1 [low, left] 为 < target
    // 2 (left, i) == 区域
    // 3 [i, high - 1]待处理区域
    // 4 [right, high - 1] > target
    int left = low - 1;
    int i = low;
    int right = high;
    for (; i < right;) {
        if (ss[i] == target) {
            i++;
            continue;
        } else if (ss[i] < target) {
            ++left;
            swap(ss[i], ss[left]);
            i++;
        } else {
            while (i < right && ss[--right] > target);
            if (i < right) {
                swap(ss[i], ss[right]);
            }
        }
    }
    // 最终
    swap(ss[i], ss[high]);
    return {left + 1, right};
}

pair<int, int> three_direction_partition3(vector<int> &ss, int low, int high) {
    int target = ss[high];
    // 循环不变式
    // 1 [low, left] 为 < target
    // 2 (left, i) == 区域
    // 3 [i, high - 1]待处理区域
    // 4 [right, high - 1] > target
    int left = low - 1;
    int i = low;
    int right = high;
    for (; i < right;) {
        if (ss[i] < target) {
            swap(ss[i++], ss[++left]);
        } else if (ss[i] > target) {
            swap(ss[--right], ss[i]);
        } else {
            i++;
        }
    }
    // 最终
    // i == high, 证明target 本身就是最大的
    // i < high, ss[i] 比 > target
    swap(ss[i], ss[high]);
    return {left + 1, right};
}

总结

patition 函数是 stl 提供的非常好用函数，用于将一堆数分成有限的几类

c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition
c++ stl 好用的算法函数 -01 partition