add MyMaxHeap and heap sort

Author: pymongo

.cargo/config.toml.example

@@ -1,16 +1,11 @@
 # https://bevyengine.org/learn/book/getting-started/setup/#enable-fast-compiles-optional
 # sudo pacman -S lld
 [target.x86_64-unknown-linux-gnu]
-rustflags = ["-Clink-arg=-fuse-ld=lld", "-Zshare-generics=y"]
+rustflags = ["-Ctarget-cpu=znver2", "-Clink-arg=-fuse-ld=lld", "-Zshare-generics=y"]
 
-# brew install michaeleisel/zld/zld
-[target.x86_64-apple-darwin]
-rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/zld", "-Zshare-generics=y"]
-
-# rustup component add llvm-tools-preview && cargo install binutils
-[target.x86_64-pc-windows-msvc]
-linker = "rust-lld.exe"
-rustflags = ["-Zshare-generics=y"]
+#zld在苹果上是「负优化」，还不如默认的ld
+#[target.x86_64-apple-darwin]
+#rustflags = ["-C", "link-arg=-fuse-ld=/usr/local/bin/zld", "-Zshare-generics=y"]
 
 [profile.dev]
 split-debuginfo = "unpacked"

Cargo.toml

@@ -1,3 +1,4 @@
+#cargo-features = ["edition2021"]
 [package]
 name = "leetcode-rust"
 version = "0.1.1"

README.md

@@ -306,7 +306,7 @@ leetcode_solutions
 |696|[Count Binary Substrings](https://leetcode.com/problems/count-binary-substrings/)|[Rust](src/easy/leetcode_very_easy.rs)|
 |700|[Search in a Binary Search Tree](https://leetcode.com/problems/search-in-a-binary-search-tree/)|[Rust](src/binary_tree/search_val_or_range_in_bst.rs)|
 |702🔒|[Search in a Sorted Array of Unknown Size](https://leetcode.com/problems/search-in-a-sorted-array-of-unknown-size/)|[Python](https://github.com/pymongo/python_leetcode/blob/master/binary_search/binary_search_unknown_size_sorted_array.py)|binary_search_first, 倍增法|
-|703|[Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/)|[Rust](src/data_structure/heap/kth_largest_element_in_a_stream.rs), [Python](https://github.com/pymongo/python_leetcode/blob/master/collections/top_k_largest_stream_min_heap.py)|
+|703|[Kth Largest Element in a Stream](https://leetcode.com/problems/kth-largest-element-in-a-stream/)|[Rust](src/data_structure/heap/kth_largest_element_in_a_stream.rs)|
 |704|[Binary Search](https://leetcode.com/problems/binary-search/)|[Python](https://github.com/pymongo/python_leetcode/blob/master/binary_search/binary_search.py)|binary_search|
 |705|[Design HashSet](https://leetcode.com/problems/design-hashset/)|[Python](https://github.com/pymongo/python_leetcode/blob/master/linked_list/impl_hashmap.py)||
 |706|[Design HashMap](https://leetcode.com/problems/design-hashmap/)|[Python](https://github.com/pymongo/python_leetcode/blob/master/linked_list/impl_hashmap.py)||
@@ -668,8 +668,6 @@ lintcode_problems
 |412|[Candy](https://lintcode.com/problem/candy/)|leetcode_135|
 |415|[Valid Palindrome](https://lintcode.com/problem/valid-palindrome/)|[Python](https://github.com/pymongo/python_leetcode/blob/master/palindrome/valid_palindrome.py)|two_pointers|
 |417|[Valid number](https://lintcode.com/problem/valid-number/)|leetcode_65|
-|418|[Integer to Roman](https://lintcode.com/problem/integer-to-roman/)|leetcode_12|
-|419|[Roman to Integer](https://lintcode.com/problem/roman-to-integer/)|leetcode_13|
 |420|[Count And Say](https://lintcode.com/problem/count-and-say/)|leetcode_38|
 |423|[Valid Parentheses](https://lintcode.com/problem/valid-parentheses/)|leetcode_20|
 |425|[Letter Combinations of a Phone Number](https://lintcode.com/problem/letter-combinations-of-a-phone-number/)|leetcode_17|

benches/bench_sorting.rs

@@ -4,6 +4,7 @@ extern crate test;
 use leetcode_rust::code_snippets::sorting::{
     bubble_sort, my_quick_sort, random_numbers_test_case, selection_sort,
 };
+use leetcode_rust::data_structure::heap::my_max_heap::MyMaxHeap;
 
 #[bench]
 fn bench_bubble_sort(bencher: &mut test::Bencher) {
@@ -19,7 +20,14 @@ fn bench_selection_sort(bencher: &mut test::Bencher) {
     bencher.iter(|| {
         let mut nums = random_numbers_test_case();
         selection_sort(&mut nums);
-        //assert!(nums.is_sorted());
+    });
+}
+
+#[bench]
+fn bench_my_heap_sort(bencher: &mut test::Bencher) {
+    bencher.iter(|| {
+        let nums = random_numbers_test_case();
+        let _ = nums.into_iter().collect::<MyMaxHeap<_>>().into_sorted_vec();
     });
 }
 
@@ -28,7 +36,17 @@ fn bench_my_quick_sort(bencher: &mut test::Bencher) {
     bencher.iter(|| {
         let mut nums = random_numbers_test_case();
         my_quick_sort(0, nums.len() - 1, &mut nums);
-        //assert!(nums.is_sorted());
+    });
+}
+
+#[bench]
+fn bench_std_heap_sort(bencher: &mut test::Bencher) {
+    bencher.iter(|| {
+        let nums = random_numbers_test_case();
+        let _ = nums
+            .into_iter()
+            .collect::<std::collections::BinaryHeap<_>>()
+            .into_sorted_vec();
     });
 }
 
@@ -38,7 +56,6 @@ fn bench_std_merge_sort(bencher: &mut test::Bencher) {
         let mut nums = random_numbers_test_case();
         #[allow(clippy::stable_sort_primitive)]
         nums.sort();
-        //assert!(nums.is_sorted());
     });
 }
 

src/bfs_dfs_backtracking/all_paths_from_source_to_target.rs

@@ -30,7 +30,7 @@ fn dfs(
     graph: &[Vec<usize>],
     dest: usize,
 ) {
-    for &next in graph[*curr.last().unwrap()].iter() {
+    for &next in &graph[*curr.last().unwrap()] {
         if visited[next] {
             continue;
         }

src/bfs_dfs_backtracking/letter_combinations_of_a_phone_number.rs

@@ -44,7 +44,7 @@ fn test_letter_combinations() {
         "23",
         &["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"],
     )];
-    for &(input, output) in &TEST_CASES {
+    for (input, output) in TEST_CASES {
         assert_eq!(letter_combinations_bfs(input.into()), output);
     }
 }

src/bfs_dfs_backtracking/max_area_of_island.rs

@@ -61,7 +61,7 @@ const TEST_CASES: [(&[&[i32]], i32); 1] = [(
 
 #[test]
 fn test_max_area_of_island() {
-    for &(grid, max_area) in &TEST_CASES {
+    for (grid, max_area) in TEST_CASES {
         let grid: Vec<Vec<i32>> = grid.iter().map(|each| each.to_vec()).collect();
         assert_eq!(max_area_of_island(grid), max_area);
     }

src/bfs_dfs_backtracking/subsets.rs

@@ -87,7 +87,7 @@ fn subsets_bfs(nums: Vec<i32>) -> Vec<Vec<i32>> {
     last.push(Vec::with_capacity(0));
     for num in nums {
         let mut curr = last.clone();
-        for each_curr in curr.iter_mut() {
+        for each_curr in &mut curr {
             each_curr.push(num);
         }
         last.append(&mut curr);

src/binary_search/median_of_two_sorted_arrays.rs

@@ -15,7 +15,7 @@ impl Solution {
         if len % 2 == 0 {
             (nums1[len / 2 - 1] + nums1[len / 2]) as f64 / 2_f64
         } else {
-            nums1[len / 2] as f64
+            f64::from(nums1[len / 2])
         }
     }
 
@@ -123,8 +123,7 @@ fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
     if len_a == 1 {
         let mut nums_b = nums2;
         let insert_index = match nums_b.binary_search(&nums1[0]) {
-            Ok(index) => index,
-            Err(index) => index,
+            Ok(index) | Err(index) => index,
         };
         nums_b.insert(insert_index, nums1[0]);
         return (nums_b[len_b / 2] as f64 + nums_b[(len_b + 1) / 2] as f64) / 2_f64;
@@ -196,16 +195,16 @@ fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
                 return if total_len % 2 == 0 {
                     if b_divider_right_index == 1 {
                         // [1,2]、[3,4]
-                        (nums1[len_a - 1] + nums2[0]) as f64 / 2_f64
+                        f64::from(nums1[len_a - 1] + nums2[0]) / 2_f64
                     } else {
                         // [1,3]、[2,4,5,6]
-                        (nums2[b_divider_right_index - 2].max(nums1[len_a - 1])
-                            + nums2[b_divider_right_index - 1]) as f64
+                        f64::from(nums2[b_divider_right_index - 2].max(nums1[len_a - 1])
+                            + nums2[b_divider_right_index - 1])
                             / 2_f64
                     }
                 } else {
                     // [1,2]、[3,4,5,6,7]
-                    nums2[b_divider_right_index - 2].max(nums1[len_a - 1]) as f64
+                    f64::from(nums2[b_divider_right_index - 2].max(nums1[len_a - 1]))
                 };
             }
             a_left = a_divider_right_index + 1;
@@ -214,9 +213,9 @@ fn find_median_sorted_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
         }
     }
     if total_len % 2 == 0 {
-        (a_divider_left.max(b_divider_left) + a_divider_right.min(b_divider_right)) as f64 / 2_f64
+        f64::from(a_divider_left.max(b_divider_left) + a_divider_right.min(b_divider_right)) / 2_f64
     } else {
-        a_divider_left.max(b_divider_left) as f64
+        f64::from(a_divider_left.max(b_divider_left))
     }
 }
 
@@ -248,17 +247,17 @@ fn move_divider_of_two_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
 
     // 如果较短数组的长度是0，统一了较长数组长度是奇数偶数的情况
     if len_a == 0 {
-        return (nums2[(len_b - 1) / 2] as f64 + nums2[len_b / 2] as f64) / 2_f64;
+        return (f64::from(nums2[(len_b - 1) / 2]) + nums2[len_b / 2] as f64) / 2_f64;
     }
     // 如果较短数组的长度是1，则较短数组的分割线左边或右边会没有值，这是一种特殊的边界条件
+    // FIXME leetcode的binary_search依然返回第一次出现的位置，但最新的rust已经改成如有重复则返回随机一个num[index]=target
     if len_a == 1 {
         let mut nums_b = nums2;
         let insert_index = match nums_b.binary_search(&nums1[0]) {
-            Ok(index) => index,
-            Err(index) => index,
+            Ok(index) | Err(index) => index,
         };
         nums_b.insert(insert_index, nums1[0]);
-        return (nums_b[len_b / 2] as f64 + nums_b[(len_b + 1) / 2] as f64) / 2_f64;
+        return (f64::from(nums_b[len_b / 2]) + f64::from(nums_b[(len_b + 1) / 2])) / 2_f64;
     }
 
     // 往后的情况，nums1和nums2的长度至少为2
@@ -326,9 +325,9 @@ fn move_divider_of_two_arrays(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
     // 如果分隔线已经在最左边，则让b_divider_left或a_divider_left等于i32的最小值，好让它在比较左边两个元素的最大值时不会被选中
     // 如果分隔线已经在最右边，则让b_divider_right或a_divider_right等于i32的最大值，好让它在比较右边两个元素的最小值时不会被选中
     if total_len % 2 == 0 {
-        (a_divider_left.max(b_divider_left) + a_divider_right.min(b_divider_right)) as f64 / 2_f64
+        f64::from(a_divider_left.max(b_divider_left) + a_divider_right.min(b_divider_right)) / 2_f64
     } else {
-        a_divider_left.max(b_divider_left) as f64
+        f64::from(a_divider_left.max(b_divider_left))
     }
 }
 
@@ -394,8 +393,8 @@ fn my_binary_search_kth(nums1: Vec<i32>, nums2: Vec<i32>) -> f64 {
         // median_left_items_count += half_k;
     }
     if (len1 + len2) % 2 == 0 {
-        (nums1[i] + nums2[j]) as f64 / 2_f64
+        f64::from(nums1[i] + nums2[j]) / 2_f64
     } else {
-        nums1[i].min(nums2[j]) as f64
+        f64::from(nums1[i].min(nums2[j]))
     }
 }

src/binary_tree/serde_binary_tree_to_leetcode_vec.rs

@@ -1,5 +1,6 @@
 /*! serialize or deserialize binary tree to leetcode vec format
 leetcode binary tree vec format example: [3,9,20,null,null,15,7] or [3,9,20,#,#,15,7]
+https://support.leetcode.com/hc/en-us/articles/360011883654-What-does-1-null-2-3-mean-in-binary-tree-representation-
 */
 use super::{Rc, RefCell, TreeLink, TreeNode};
 

src/bitwise/find_single_number.rs

@@ -22,7 +22,7 @@ fn single_number_xor_solution(nums: Vec<i32>) -> i32 {
 /// single_number_2的bitwise解法要用状态机去理解，不方便背诵
 fn single_number_2_sum_solution(nums: Vec<i32>) -> i32 {
     let nums_set: std::collections::HashSet<i64> =
-        nums.clone().into_iter().map(|num| num as i64).collect();
+        nums.clone().into_iter().map(i64::from).collect();
     let nums_set_sum = nums_set.into_iter().sum::<i64>();
     let nums_sum = nums.into_iter().map(i64::from).sum::<i64>();
     ((nums_set_sum * 3 - nums_sum) / 2) as i32

src/code_snippets/random_i32.rs

@@ -41,22 +41,3 @@ pub fn rand_range(min: i32, max: i32) -> i32 {
     // 一般只记忆这个简单的 用MOD生成一定范围内的随机数
     random_num % max + min
 }
-
-#[derive(Clone)]
-pub struct CookieRaw {
-    pub token: Option<String>,
-    pub current_igbid: Option<String>,
-}
-
-impl ToString for CookieRaw {
-    fn to_string(&self) -> String {
-        format!(
-            "token={};current_igbid={}",
-            self.token.clone().unwrap_or_default(),
-            self.current_igbid.clone().unwrap_or_default()
-        )
-    }
-}
-
-#[test]
-fn feature() {}

src/counter/anagrams.rs

@@ -42,7 +42,7 @@ fn anagram_mappings(mut a: Vec<i32>, b: Vec<i32>) -> Vec<i32> {
     for (i, b) in b.into_iter().enumerate() {
         map.insert(b, i as i32);
     }
-    for a in a.iter_mut() {
+    for a in &mut a {
         *a = *map.get(a).unwrap();
     }
     a

src/counter/count_good_meals.rs

@@ -18,10 +18,10 @@ fn count_pairs_permutation_solution(nums: Vec<i32>) -> i32 {
         counter.push(i64::from(value));
     }
     // unique.sort_unstable(); // 由于nums是有序的，插入counter时也是有序的，所以不用排序
-    let n = unique.len();
+    let unique_len = unique.len();
     let mut ret = 0_i64;
-    for i in 0..n {
-        for j in i..n {
+    for i in 0..unique_len {
+        for j in i..unique_len {
             if is_power_of_2(unique[i] + unique[j]) {
                 if i == j {
                     // math.comb(count, 2)

src/counter/count_num1_square_eq_two_num2_product.rs

@@ -51,7 +51,7 @@ fn test_diagonal_sum() {
         (&[7, 7, 8, 3], &[1, 2, 9, 7], 2),
         (&[4, 7, 9, 11, 23], &[3, 5, 1024, 12, 18], 0),
     ];
-    for &(nums1, nums2, res) in &TEST_CASES {
+    for (nums1, nums2, res) in TEST_CASES {
         assert_eq!(num_triplets(nums1.to_vec(), nums2.to_vec()), res);
     }
 }

src/counter/number_of_equivalent_domino_pairs.rs

@@ -10,7 +10,7 @@ fn num_equiv_domino_pairs(dominoes: Vec<Vec<i32>>) -> i32 {
             each[0] * 10 + each[1]
         } as usize;
         // 这里是C(n,2)的计数方式
-        ret += counter[index] as i32;
+        ret += i32::from(counter[index]);
         counter[index] += 1;
     }
     ret

src/counter/number_of_good_pairs.rs

@@ -13,7 +13,7 @@ fn num_identical_pairs(nums: Vec<i32>) -> i32 {
     // array暂不支持into_iter, issue#66145
     counter
         .iter()
-        .map(|&v| (v as i32 - 1) * v as i32 / 2)
+        .map(|&v| (i32::from(v) - 1) * i32::from(v) / 2)
         .sum::<i32>()
 }
 
@@ -43,11 +43,11 @@ fn number_of_good_pairs_v2(nums: Vec<i32>) -> i32 {
 */
 fn number_of_good_pairs_v3(nums: Vec<i32>) -> i32 {
     let mut counter = std::collections::HashMap::<i32, u8>::with_capacity(nums.len());
-    for num in nums.into_iter() {
+    for num in nums {
         *counter.entry(num).or_default() += 1;
     }
     counter
         .into_iter()
-        .map(|(_k, v)| (v as i32 - 1) * v as i32 / 2)
+        .map(|(_k, v)| (i32::from(v) - 1) * i32::from(v) / 2)
         .sum::<i32>()
 }

src/data_structure/heap/kth_largest_element_in_a_stream.rs

@@ -5,6 +5,10 @@
 如果富豪人数等于k则
     如果新富豪比末位富豪更有钱，则踢掉最穷的富豪，新富豪入堆，重新heapify
     否则小根堆维持不变
+
+为什么用小根堆?
+「末尾淘汰制度」的思想，堆里面至多有k个元素，新来的元素至少要击败其中一个，才能进入堆
+说是小根堆，实际上存的是最大的几个，类似福布斯富豪榜，新来的必须足够大才能上榜
 */
 use std::cmp::Reverse;
 use std::collections::BinaryHeap;
@@ -25,6 +29,7 @@ impl KthLargest {
                 continue;
             }
             if num > min_heap.peek().unwrap().0 {
+                // heapq.heapreplace
                 min_heap.pop().unwrap();
                 min_heap.push(Reverse(num));
             }

src/data_structure/heap/mod.rs

@@ -1,4 +1,6 @@
 mod kth_largest_element_in_a_stream;
+#[allow(clippy::module_name_repetitions)]
+pub mod my_max_heap;
 mod seat_reservation_manager;
 mod single_threaded_cpu;
 mod top_k_frequent_elements;