remove compare fn to make impl clear

Author: douchuan

Makefile

@@ -10,7 +10,7 @@ clippy:
 	$(CARGO) clippy
 
 test:
-	#$(TEST) -- --nocapture --test-threads=1
+	#$(TEST) -- --nocapture
 	$(TEST)
 
 test_dp:

src/common/heap.rs

@@ -35,19 +35,16 @@ pub struct BinaryHeap<K> {
     keys: Vec<K>,
 }
 
-impl<K> BinaryHeap<K> {
-    pub fn new<F>(mut keys: Vec<K>, test: &F) -> Self
-    where
-        F: Fn(&K, &K) -> bool,
-    {
-        build_heap(&mut keys, test);
+impl<K> BinaryHeap<K>
+where
+    K: Ord,
+{
+    pub fn new(mut keys: Vec<K>) -> Self {
+        build_heap(&mut keys);
         Self { keys }
     }
 
-    pub fn pop<F>(&mut self, test: &F) -> Option<K>
-    where
-        F: Fn(&K, &K) -> bool,
-    {
+    pub fn pop(&mut self) -> Option<K> {
         let len = self.keys.len();
         if len > 0 {
             // 从长度为 n 的数组中删除第一个元素需要线性时间 O(n)。
@@ -57,33 +54,27 @@ impl<K> BinaryHeap<K> {
             // 个元素，然后将数组的长度减一。
             self.keys.swap(0, len - 1);
             let key = self.keys.pop();
-            heapify(&mut self.keys, 0, test);
+            heapify(&mut self.keys, 0);
             key
         } else {
             None
         }
     }
 
-    pub fn set<F>(&mut self, i: usize, key: K, test: &F)
-    where
-        F: Fn(&K, &K) -> bool,
-    {
+    pub fn set(&mut self, i: usize, key: K) {
         match self.keys.get(i) {
-            Some(v) if test(&key, v) => {
+            Some(v) if &key >= v => {
                 self.keys[i] = key;
-                heap_fix(&mut self.keys, i, test);
+                heap_fix(&mut self.keys, i);
             }
             _ => (),
         }
     }
 
-    pub fn insert<F>(&mut self, key: K, test: &F)
-    where
-        F: Fn(&K, &K) -> bool,
-    {
+    pub fn insert(&mut self, key: K) {
         let i = self.keys.len();
         self.keys.push(key);
-        heap_fix(&mut self.keys, i, test);
+        heap_fix(&mut self.keys, i);
     }
 
     //for test
@@ -92,9 +83,9 @@ impl<K> BinaryHeap<K> {
     }
 }
 
-pub fn heapify<K, F>(keys: &mut [K], mut i: usize, test: &F)
+pub fn heapify<K>(keys: &mut [K], mut i: usize)
 where
-    F: Fn(&K, &K) -> bool,
+    K: Ord,
 {
     let n = keys.len();
     loop {
@@ -103,13 +94,13 @@ where
         let mut m = i;
 
         if let Some(v) = keys.get(l) {
-            if l < n && test(v, &keys[m]) {
+            if l < n && v >= &keys[m] {
                 m = l;
             }
         }
 
         if let Some(v) = keys.get(r) {
-            if r < n && test(v, &keys[m]) {
+            if r < n && v >= &keys[m] {
                 m = r;
             }
         }
@@ -123,9 +114,9 @@ where
     }
 }
 
-pub fn build_heap<K, F>(keys: &mut [K], compare: &F)
+pub fn build_heap<K>(keys: &mut [K])
 where
-    F: Fn(&K, &K) -> bool,
+    K: Ord,
 {
     // i以 n / 2作为第一个分支节点，开始构建heap。
     // 因为叶子结点，已经满足堆定义，所以从二叉树倒数第二层最后一个节点
@@ -135,21 +126,21 @@ where
     // index = 2 ^ (p - 1) - 1 = 2 ^ ( log(n) - 1) - 1 <= n / 2
     let mut i = keys.len() as i32 / 2;
     while i >= 0 {
-        heapify(keys, i as usize, compare);
+        heapify(keys, i as usize);
         i -= 1;
     }
 }
 
 // 与heapify的区别:
 // heapify 是从i节点开始，调整子树 (向下调整)
 // heap_fix 是从i节点开始，调整父节点（向上调整）
-fn heap_fix<K, F>(keys: &mut [K], mut i: usize, test: &F)
+fn heap_fix<K>(keys: &mut [K], mut i: usize)
 where
-    F: Fn(&K, &K) -> bool,
+    K: Ord,
 {
     while i > 0 {
         let parent = parent!(i);
-        if test(&keys[i], &keys[parent]) {
+        if keys[i] >= keys[parent] {
             keys.swap(i, parent);
             i = parent;
         }

src/math/mod.rs

@@ -1 +1,2 @@
 pub mod mysqrt;
+pub mod sparse_vector;

src/tree/binary/sparse_vector.rs renamed to src/math/sparse_vector.rs

@@ -3,20 +3,15 @@
 /// It includes methods for addition, subtraction,
 /// dot product, scalar product, unit vector, and Euclidean norm.
 ///
-/// The implementation is a symbol table of indices and values for which the vector
-/// coordinates are nonzero. This makes it efficient when most of the vector coordindates
-/// are zero.
+/// The implementation is a symbol table (Red Black Tree) of indices and values
+/// for which the vector coordinates are nonzero. This makes it efficient when
+/// most of the vector coordindates are zero.
 ///
 /// ref: https://github.com/kevin-wayne/algs4.git
 use crate::tree::binary::rb2::RedBlackTreeV2;
 use crate::tree::binary::Tree;
 use std::ops::{Add, Sub};
 
-#[derive(Debug)]
-pub enum Err {
-    Dimension,
-}
-
 pub struct SparseVector {
     d: usize,
     st: Tree<usize, f64>,
@@ -40,7 +35,7 @@ impl SparseVector {
 
     /// Returns the ith coordinate of this vector
     pub fn get(&self, i: usize) -> f64 {
-        self.st.get(&i).cloned().unwrap_or(0.0)
+        *self.st.get(&i).unwrap_or(&0.0)
     }
 
     /// Returns the number of nonzero entries in this vector.
@@ -58,7 +53,7 @@ impl SparseVector {
         if self.d != that.d {
             Err(Err::Dimension)
         } else {
-            let keys = if self.st.size() <= that.st.size() {
+            let keys = if self.nnz() <= that.nnz() {
                 self.st.keys()
             } else {
                 that.st.keys()
@@ -85,34 +80,20 @@ impl SparseVector {
     /// Returns the scalar-vector product of this vector with the specified scalar.
     pub fn scale(&self, alpha: f64) -> Self {
         let mut c = Self::new(self.d);
-        for i in self.st.keys() {
-            c.put(*i, alpha * self.get(*i));
+        for &i in self.st.keys() {
+            c.put(i, alpha * self.get(i));
         }
         c
     }
 }
 
-impl ToString for SparseVector {
-    fn to_string(&self) -> String {
-        let keys = self.st.keys();
-        let mut v = Vec::with_capacity(keys.len());
-        for i in self.st.keys() {
-            v.push(format!("({}, {})", i, self.get(*i)));
-        }
-        v.join("")
-    }
-}
-
 impl Add for SparseVector {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
-        let mut c = Self::new(self.d);
-        for i in self.st.keys() {
-            c.put(*i, self.get(*i));
-        }
-        for i in rhs.st.keys() {
-            c.put(*i, c.get(*i) + rhs.get(*i));
+        let mut c = self.clone();
+        for &i in rhs.st.keys() {
+            c.put(i, c.get(i) + rhs.get(i));
         }
         c
     }
@@ -122,13 +103,36 @@ impl Sub for SparseVector {
     type Output = Self;
 
     fn sub(self, rhs: Self) -> Self::Output {
-        let mut c = Self::new(self.d);
-        for i in self.st.keys() {
-            c.put(*i, self.get(*i));
+        let mut c = self.clone();
+        for &i in rhs.st.keys() {
+            c.put(i, c.get(i) - rhs.get(i));
+        }
+        c
+    }
+}
+
+impl ToString for SparseVector {
+    fn to_string(&self) -> String {
+        let keys = self.st.keys();
+        let mut v = Vec::with_capacity(keys.len());
+        for &i in keys {
+            v.push(format!("({}, {})", i, self.get(i)));
         }
-        for i in rhs.st.keys() {
-            c.put(*i, c.get(*i) - rhs.get(*i));
+        v.join("")
+    }
+}
+
+impl Clone for SparseVector {
+    fn clone(&self) -> Self {
+        let mut c = Self::new(self.d);
+        for &i in self.st.keys() {
+            c.put(i, self.get(i));
         }
         c
     }
 }
+
+#[derive(Debug)]
+pub enum Err {
+    Dimension,
+}

src/search/binary.rs

@@ -4,16 +4,16 @@ use std::cmp::Ordering;
 
 pub fn search<K>(xs: &[K], k: K) -> Option<usize>
 where
-    K: std::cmp::PartialOrd,
+    K: Ord,
 {
     let mut l = 0;
     let mut u = xs.len();
 
     while l < u {
         let m = (l + u) / 2;
-        match xs[m].partial_cmp(&k) {
-            Some(Ordering::Equal) => return Some(m),
-            Some(Ordering::Less) => l = m + 1,
+        match xs[m].cmp(&k) {
+            Ordering::Equal => return Some(m),
+            Ordering::Less => l = m + 1,
             _ => u = m,
         }
     }

src/sort/bubble.rs

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

src/sort/heap.rs

@@ -5,15 +5,14 @@
 
 use crate::common::heap::{self, BinaryHeap};
 
-pub fn sort<T, F>(a: &[T], compare: &F) -> Vec<T>
+pub fn sort<T>(a: &[T]) -> Vec<T>
 where
-    T: Copy,
-    F: Fn(&T, &T) -> bool,
+    T: Ord + Copy,
 {
     let data = Vec::from(a);
-    let mut heap = BinaryHeap::new(data, compare);
+    let mut heap = BinaryHeap::new(data);
     let mut res = Vec::with_capacity(a.len());
-    while let Some(v) = heap.pop(compare) {
+    while let Some(v) = heap.pop() {
         res.push(v);
     }
     res
@@ -28,16 +27,15 @@ where
 /// 就地排序，小 -> 大
 pub fn floyd_sort<T>(a: &mut [T])
 where
-    T: std::cmp::PartialOrd,
+    T: Ord,
 {
     // 构建最大堆
-    let compare = |x: &T, y: &T| x >= y;
-    heap::build_heap(a, &compare);
+    heap::build_heap(a);
 
     let mut i = a.len();
     while i > 1 {
         i -= 1;
         a.swap(0, i);
-        heap::heapify(&mut a[0..i], 0, &compare);
+        heap::heapify(&mut a[0..i], 0);
     }
 }

src/sort/insert.rs

@@ -2,16 +2,16 @@
 //!
 //! 基本思想是将一个value插入到有序表中
 
-pub fn sort<T, F>(a: &mut [T], compare: F)
+pub fn sort<T>(a: &mut [T])
 where
-    F: Fn(&T, &T) -> bool,
+    T: Ord,
 {
     let len = a.len();
     // 注意起始索引
     for i in 1..len {
         // 将a[i]插入到a[i-1]，a[i-2]，a[i-3]……之中
         let mut j = i;
-        while j > 0 && compare(&a[j], &a[j - 1]) {
+        while j > 0 && a[j] < a[j - 1] {
             a.swap(j, j - 1);
             j -= 1;
         }