Merge pull request wangzheng0822#79 from Liam0205/12_sorts

[C++][12_sorts] 归并排序和快速排序

Author: wangzheng0822

c-cpp/12_sorts/.gitkeep

@@ -0,0 +1,62 @@
+/**
+ * Created by Liam Huang (Liam0205) on 2018/10/17.
+ */
+
+#ifndef SORTS_MERGE_SORT_HPP_
+#define SORTS_MERGE_SORT_HPP_
+
+#include <functional>
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace detail {
+template <typename InputIt1, typename InputIt2, typename OutputIt,
+ typename BinaryPred = std::less<typename std::iterator_traits<InputIt1>::value_type>>
+OutputIt merge(InputIt1 first1, InputIt1 last1,
+ InputIt2 first2, InputIt2 last2,
+ OutputIt d_first,
+ BinaryPred comp = BinaryPred()) {
+ for (; first1 != last1; ++d_first) {
+ if (first2 == last2) {
+ return std::copy(first1, last1, d_first);
+ }
+ if (comp(*first2, *first1)) {
+ *d_first = *first2;
+ ++first2;
+ } else {
+ *d_first = *first1;
+ ++first1;
+ }
+ }
+ return std::copy(first2, last2, d_first);
+}
+} // namespace detail
+
+template <typename FrwdIt,
+ typename BinaryPred = std::less<typename std::iterator_traits<FrwdIt>::value_type>>
+void merge_sort(FrwdIt first, FrwdIt last, BinaryPred comp = BinaryPred()) {
+ const auto len = std::distance(first, last);
+ if (len <= 1) { return; }
+ auto cut = first + len / 2;
+ merge_sort(first, cut, comp);
+ merge_sort(cut, last, comp);
+ std::vector<typename std::iterator_traits<FrwdIt>::value_type> tmp;
+ tmp.reserve(len);
+ detail::merge(first, cut, cut, last, std::back_inserter(tmp), comp);
+ std::copy(tmp.begin(), tmp.end(), first);
+}
+
+template <typename BidirIt,
+ typename BinaryPred = std::less<typename std::iterator_traits<BidirIt>::value_type>>
+void inplace_merge_sort(BidirIt first, BidirIt last, BinaryPred comp = BinaryPred()) {
+ const auto len = std::distance(first, last);
+ if (len <= 1) { return; }
+ auto cut = first + len / 2;
+ merge_sort(first, cut, comp);
+ merge_sort(cut, last, comp);
+ std::inplace_merge(first, cut, last, comp);
+}
+
+#endif // SORTS_MERGE_SORT_HPP_
+

c-cpp/12_sorts/merge_sort.hpp

@@ -0,0 +1,28 @@
+/**
+ * Created by Liam Huang (Liam0205) on 2018/10/17.
+ */
+
+#include <iostream>
+#include <vector>
+#include "merge_sort.hpp"
+
+int main() {
+ const std::vector<int> test_data{0, -1, 3, 190, -500};
+
+ std::vector<int> a{test_data};
+ merge_sort(a.begin(), a.end());
+ for (auto i : a) {
+ std::cout << i << ' ';
+ }
+ std::cout << std::endl;
+
+ std::vector<int> b{test_data};
+ inplace_merge_sort(b.begin(), b.end());
+ for (auto i : b) {
+ std::cout << i << ' ';
+ }
+ std::cout << std::endl;
+
+ return 0;
+}
+

c-cpp/12_sorts/merge_sort_test.cc

@@ -0,0 +1,71 @@
+/**
+ * Created by Liam Huang (Liam0205) on 2018/10/17.
+ */
+
+#ifndef SORTS_QUICK_SORT_HPP_
+#define SORTS_QUICK_SORT_HPP_
+
+#include <functional>
+#include <iterator>
+#include <algorithm>
+#include <utility>
+
+namespace detail {
+template <typename T, typename Compare = std::less<T>>
+const T& median(const T& a, const T& b, const T& c, Compare comp = Compare()) {
+ if (comp(a, b) and comp(b, c) or comp(c, b) and comp(b, a)) {
+ return b;
+ } else if (comp(b, c) and comp(c, a) or comp(a, c) and comp(c, b)) {
+ return c;
+ } else {
+ return a;
+ }
+}
+
+template <typename Iter,
+ typename T = typename std::iterator_traits<Iter>::value_type,
+ typename Compare = std::less<T>>
+const T& iter_median(Iter a, Iter b, Iter c, Compare comp = Compare()) {
+ return median(*a, *b, *c, comp);
+}
+
+template <typename BidirIt,
+ typename T = typename std::iterator_traits<BidirIt>::value_type,
+ typename Compare = std::less<T>>
+std::pair<BidirIt, BidirIt> inplace_partition(BidirIt first,
+ BidirIt last,
+ const T& pivot,
+ Compare comp = Compare()) {
+ BidirIt last_less, last_greater, first_equal, last_equal;
+ for (last_less = first, last_greater = first, first_equal = last;
+ last_greater != first_equal; ) {
+ if (comp(*last_greater, pivot)) {
+ std::iter_swap(last_greater++, last_less++);
+ } else if (comp(pivot, *last_greater)) {
+ ++last_greater;
+ } else { // pivot == *last_greater
+ std::iter_swap(last_greater, --first_equal);
+ }
+ }
+ const auto cnt = std::distance(first_equal, last);
+ std::swap_ranges(first_equal, last, last_less);
+ first_equal = last_less;
+ last_equal = first_equal + cnt;
+ return {first_equal, last_equal};
+}
+} // namespace detail
+
+template <typename BidirIt,
+ typename T = typename std::iterator_traits<BidirIt>::value_type,
+ typename Compare = std::less<T>>
+void quick_sort(BidirIt first, BidirIt last, Compare comp = Compare()) {
+ for (auto size = std::distance(first, last); size > 1; size = std::distance(first, last)) {
+ const T pivot = detail::iter_median(first, last - 1, first + size / 2, comp);
+ const auto eq = detail::inplace_partition(first, last, pivot, comp);
+ quick_sort(first, eq.first, comp);
+ first = eq.second; // Liam Huang: economize half of recursive calling.
+ }
+}
+
+#endif // SORTS_QUICK_SORT_HPP_
+

c-cpp/12_sorts/quick_sort.hpp

@@ -0,0 +1,25 @@
+/**
+ * Created by Liam Huang (Liam0205) on 2018/10/17.
+ */
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+#include "quick_sort.hpp"
+
+void test_quick_sort(std::vector<int> test_data) {
+ quick_sort(test_data.begin(), test_data.end());
+ std::transform(test_data.begin(), test_data.end(),
+ std::ostream_iterator<int>(std::cout, " "), [](int i){ return i; });
+ std::cout << '\n';
+}
+
+int main() {
+ test_quick_sort({-3, -1, 1, -2, -3, 0, -3, 100, 1, 1, -100});
+ test_quick_sort({1, 1, 1});
+ test_quick_sort({1, 0, -1});
+ test_quick_sort({1});
+ return 0;
+}
+