loose constrain on generic arg

Author: douchuan

benches/sort.rs

@@ -10,7 +10,7 @@ fn small_merge_v1(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v1::sort(&mut numbs, f);
+        sort::merge::v1::sort(&mut numbs, &f);
     });
 }
 
@@ -20,7 +20,7 @@ fn large_merge_v1(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v1::sort(&mut numbs, f);
+        sort::merge::v1::sort(&mut numbs, &f);
     });
 }
 
@@ -30,7 +30,7 @@ fn large_sorted_asc_merge_v1(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v1::sort(&mut numbs, f);
+        sort::merge::v1::sort(&mut numbs, &f);
     });
 }
 
@@ -40,7 +40,7 @@ fn large_sorted_desc_merge_v1(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v1::sort(&mut numbs, f);
+        sort::merge::v1::sort(&mut numbs, &f);
     });
 }
 
@@ -50,7 +50,7 @@ fn eq_data_merge_v1(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v1::sort(&mut numbs, f);
+        sort::merge::v1::sort(&mut numbs, &f);
     });
 }
 
@@ -59,7 +59,7 @@ fn small_merge_v2(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v2::sort(&mut numbs, f);
+        sort::merge::v2::sort(&mut numbs, &f);
     });
 }
 
@@ -69,7 +69,7 @@ fn large_merge_v2(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v2::sort(&mut numbs, f);
+        sort::merge::v2::sort(&mut numbs, &f);
     });
 }
 
@@ -79,7 +79,7 @@ fn large_sorted_asc_merge_v2(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v2::sort(&mut numbs, f);
+        sort::merge::v2::sort(&mut numbs, &f);
     });
 }
 
@@ -89,7 +89,7 @@ fn large_sorted_desc_merge_v2(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v2::sort(&mut numbs, f);
+        sort::merge::v2::sort(&mut numbs, &f);
     });
 }
 
@@ -99,7 +99,7 @@ fn eq_data_merge_v2(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v2::sort(&mut numbs, f);
+        sort::merge::v2::sort(&mut numbs, &f);
     });
 }
 
@@ -108,7 +108,7 @@ fn small_merge_v3(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v3::sort(&mut numbs, f);
+        sort::merge::v3::sort(&mut numbs, &f);
     });
 }
 
@@ -118,7 +118,7 @@ fn large_merge_v3(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v3::sort(&mut numbs, f);
+        sort::merge::v3::sort(&mut numbs, &f);
     });
 }
 
@@ -128,7 +128,7 @@ fn large_sorted_asc_merge_v3(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v3::sort(&mut numbs, f);
+        sort::merge::v3::sort(&mut numbs, &f);
     });
 }
 
@@ -138,7 +138,7 @@ fn large_sorted_desc_merge_v3(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v3::sort(&mut numbs, f);
+        sort::merge::v3::sort(&mut numbs, &f);
     });
 }
 
@@ -148,16 +148,16 @@ fn eq_data_merge_v3(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = data.clone();
         let f = |x: i32, y: i32| x > y;
-        sort::merge::v3::sort(&mut numbs, f);
+        sort::merge::v3::sort(&mut numbs, &f);
     });
 }
 
 #[bench]
 fn small_quick(b: &mut Bencher) {
     b.iter(|| {
         let mut numbs = [1, 2, 4, 8, 9, 9, 13, 17, 22];
-        let f = |x: i32, y: i32| x > y;
-        sort::quick::sort(&mut numbs, f);
+        let f = |x: &i32, y: &i32| x > y;
+        sort::quick::sort(&mut numbs, &f);
     });
 }
 
@@ -166,8 +166,8 @@ fn large_quick(b: &mut Bencher) {
     let data = util::random_data(util::DATA_LEN);
     b.iter(|| {
         let mut numbs = data.clone();
-        let f = |x: i32, y: i32| x > y;
-        sort::quick::sort(&mut numbs, f);
+        let f = |x: &i32, y: &i32| x > y;
+        sort::quick::sort(&mut numbs, &f);
     });
 }
 
@@ -176,8 +176,8 @@ fn large_sorted_asc_quick(b: &mut Bencher) {
     let data = util::sorted_data_asc(util::DATA_LEN);
     b.iter(|| {
         let mut numbs = data.clone();
-        let f = |x: i32, y: i32| x > y;
-        sort::quick::sort(&mut numbs, f);
+        let f = |x: &i32, y: &i32| x > y;
+        sort::quick::sort(&mut numbs, &f);
     });
 }
 
@@ -186,8 +186,8 @@ fn large_sorted_desc_quick(b: &mut Bencher) {
     let data = util::sorted_data_desc(util::DATA_LEN);
     b.iter(|| {
         let mut numbs = data.clone();
-        let f = |x: i32, y: i32| x > y;
-        sort::quick::sort(&mut numbs, f);
+        let f = |x: &i32, y: &i32| x > y;
+        sort::quick::sort(&mut numbs, &f);
     });
 }
 
@@ -196,8 +196,8 @@ fn eq_data_quick(b: &mut Bencher) {
     let data = util::eq_data(util::DATA_LEN);
     b.iter(|| {
         let mut numbs = data.clone();
-        let f = |x: i32, y: i32| x > y;
-        sort::quick::sort(&mut numbs, f);
+        let f = |x: &i32, y: &i32| x > y;
+        sort::quick::sort(&mut numbs, &f);
     });
 }
 

src/common/heap.rs

@@ -30,22 +30,26 @@ macro_rules! parent {
 }
 
 // 用数组实现隐式二叉堆
-pub struct BinaryHeap<K, F> {
+pub struct BinaryHeap<K> {
     keys: Vec<K>,
-    test: F,
 }
 
-impl<K, F> BinaryHeap<K, F>
+impl<K> BinaryHeap<K>
 where
     K: Copy,
-    F: Fn(K, K) -> bool + Copy,
 {
-    pub fn new(mut keys: Vec<K>, test: F) -> Self {
+    pub fn new<F>(mut keys: Vec<K>, test: &F) -> Self
+    where
+        F: Fn(K, K) -> bool,
+    {
         build_heap(&mut keys, test);
-        Self { keys, test }
+        Self { keys }
     }
 
-    pub fn pop(&mut self) -> Option<K> {
+    pub fn pop<F>(&mut self, test: &F) -> Option<K>
+    where
+        F: Fn(K, K) -> bool,
+    {
         let len = self.keys.len();
         if len > 0 {
             // 从长度为 n 的数组中删除第一个元素需要线性时间 O(n)。
@@ -55,18 +59,19 @@ where
             // 个元素，然后将数组的长度减一。
             self.keys.swap(0, len - 1);
             let key = self.keys.pop();
-            let test = self.test;
             heapify(&mut self.keys, 0, test);
             key
         } else {
             None
         }
     }
 
-    pub fn set(&mut self, i: usize, key: K) {
+    pub fn set<F>(&mut self, i: usize, key: K, test: &F)
+    where
+        F: Fn(K, K) -> bool,
+    {
         match self.keys.get(i) {
             Some(v) => {
-                let test = self.test;
                 if test(key, *v) {
                     self.keys[i] = key;
                     heap_fix(&mut self.keys, i, test);
@@ -76,8 +81,10 @@ where
         }
     }
 
-    pub fn insert(&mut self, key: K) {
-        let test = self.test;
+    pub fn insert<F>(&mut self, key: K, test: &F)
+    where
+        F: Fn(K, K) -> bool,
+    {
         let i = self.keys.len();
         self.keys.push(key);
         heap_fix(&mut self.keys, i, test);
@@ -89,10 +96,10 @@ where
     }
 }
 
-pub fn heapify<K, F>(keys: &mut [K], mut i: usize, test: F)
+pub fn heapify<K, F>(keys: &mut [K], mut i: usize, test: &F)
 where
     K: Copy,
-    F: Fn(K, K) -> bool + Copy,
+    F: Fn(K, K) -> bool,
 {
     let n = keys.len();
     loop {
@@ -121,34 +128,31 @@ where
     }
 }
 
-pub fn build_heap<K, F>(keys: &mut [K], test: F)
+pub fn build_heap<K, F>(keys: &mut [K], test: &F)
 where
     K: Copy,
-    F: Fn(K, K) -> bool + Copy,
+    F: Fn(K, K) -> bool,
 {
     // i以 n / 2作为第一个分支节点，开始构建heap。
     // 因为叶子结点，已经满足堆定义，所以从二叉树倒数第二层最后一个节点
     // 开始构建，这个分支节点的index，根据等比数列求和公式得到:
     // (2 ^ 0 + 2 ^ 1 ... 2 ^ (p - 1) = 2 ^ (p - 1) - 1)
     // p为二叉树层数等于log(n)
     // index = 2 ^ (p - 1) - 1 = 2 ^ ( log(n) - 1) - 1 <= n / 2
-    let mut i = keys.len() / 2;
-    loop {
-        heapify(keys, i, test);
-        if i == 0 {
-            break;
-        } else {
-            i -= 1;
-        }
+    let mut i = keys.len() as i32 / 2;
+    while i >= 0 {
+        heapify(keys, i as usize, test);
+        i -= 1;
     }
 }
 
 // 与heapify的区别:
 // heapify 是从i节点开始，调整子树 (向下调整)
 // heap_fix 是从i节点开始，调整父节点（向上调整）
-fn heap_fix<K: Copy, F>(keys: &mut [K], mut i: usize, test: F)
+fn heap_fix<K, F>(keys: &mut [K], mut i: usize, test: &F)
 where
-    F: Fn(K, K) -> bool + Copy,
+    K: Copy,
+    F: Fn(K, K) -> bool,
 {
     while i > 0 {
         let parent = parent!(i);

src/sort/bubble.rs

@@ -13,16 +13,16 @@
 //! 若初始状态反序，时间复杂度 O(n^2)
 //! 稳定排序算法
 
-pub fn sort<T: Copy, F>(a: &mut [T], test: F)
+pub fn sort<T, F>(a: &mut [T], compare: F)
 where
-    F: Fn(T, T) -> bool + Copy,
+    F: Fn(&T, &T) -> bool,
 {
     let len = a.len();
     for i in 0..len.saturating_sub(1) {
         let mut swapped = false;
 
         for j in 0..(len - 1 - i) {
-            if test(a[j], a[j + 1]) {
+            if compare(&a[j], &a[j + 1]) {
                 a.swap(j, j + 1);
                 swapped = true;
             }

src/sort/heap.rs

@@ -5,14 +5,15 @@
 
 use crate::common::heap::{self, BinaryHeap};
 
-pub fn sort<T: Copy, F>(a: &[T], test: F) -> Vec<T>
+pub fn sort<T, F>(a: &[T], compare: &F) -> Vec<T>
 where
-    F: Fn(T, T) -> bool + Copy,
+    T: Copy,
+    F: Fn(T, T) -> bool,
 {
     let data = Vec::from(a);
-    let mut heap = BinaryHeap::new(data, test);
+    let mut heap = BinaryHeap::new(data, compare);
     let mut res = Vec::with_capacity(a.len());
-    while let Some(v) = heap.pop() {
+    while let Some(v) = heap.pop(compare) {
         res.push(v);
     }
     res
@@ -25,15 +26,18 @@ where
 /// 这一算法是原地排序的，无需使用额外的空间来存储结果
 ///
 /// 就地排序，小 -> 大
-pub fn floyd_sort<T: Copy + std::cmp::PartialOrd>(a: &mut [T]) {
+pub fn floyd_sort<T>(a: &mut [T])
+where
+    T: Copy + std::cmp::PartialOrd,
+{
     // 构建最大堆
-    let test = |x: T, y: T| x >= y;
-    heap::build_heap(a, test);
+    let compare = |x: T, y: T| x >= y;
+    heap::build_heap(a, &compare);
 
     let mut i = a.len();
     while i > 1 {
         i -= 1;
         a.swap(0, i);
-        heap::heapify(&mut a[0..i], 0, test);
+        heap::heapify(&mut a[0..i], 0, &compare);
     }
 }