feat: update solutions to lcof problems: No.40,41

YangFong · YangFong · commit c41240e474b5 · 2022-05-27T10:22:16.000+08:00
- 面试题40. 最小的k个数
- 面试题41. 数据流中的中位数
diff --git a/lcof/面试题40. 最小的k个数/README.md b/lcof/面试题40. 最小的k个数/README.md
@@ -160,6 +160,65 @@ public:
 };
 ```
 
+### **TypeScript**
+
+```ts
+function getLeastNumbers(arr: number[], k: number): number[] {
+    let start = 0;
+    let end = arr.length;
+    while (start < end && end > k) {
+        const index = start + Math.floor(Math.random() * (end - start));
+        [arr[start], arr[index]] = [arr[index], arr[start]];
+        const num = arr[start];
+        let mark = start;
+        for (let i = start + 1; i < end; i++) {
+            if (arr[i] < num) {
+                mark++;
+                [arr[i], arr[mark]] = [arr[mark], arr[i]];
+            }
+        }
+        [arr[start], arr[mark]] = [arr[mark], arr[start]];
+
+        if (mark >= k) {
+            end = mark;
+        } else {
+            start = mark + 1;
+        }
+    }
+    return arr.slice(0, k);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn get_least_numbers(mut arr: Vec<i32>, k: i32) -> Vec<i32> {
+        let k = k as usize;
+        let mut start = 0;
+        let mut end = arr.len();
+        while start < end && end > k {
+            let num = arr[start];
+            let mut mark = start;
+            for i in (start + 1)..end {
+                if arr[i] < num {
+                    mark += 1;
+                    arr.swap(i, mark);
+                }
+            }
+            arr.swap(start, mark);
+
+            if mark <= k {
+                start = mark + 1;
+            } else {
+                end = mark
+            }
+        }
+        arr[0..k].to_vec()
+    }
+}
+```
+
 ### **...**
 
 ```
diff --git a/lcof/面试题40. 最小的k个数/Solution.rs b/lcof/面试题40. 最小的k个数/Solution.rs
@@ -0,0 +1,25 @@
+impl Solution {
+    pub fn get_least_numbers(mut arr: Vec<i32>, k: i32) -> Vec<i32> {
+        let k = k as usize;
+        let mut start = 0;
+        let mut end = arr.len();
+        while start < end && end > k {
+            let num = arr[start];
+            let mut mark = start;
+            for i in (start + 1)..end {
+                if arr[i] < num {
+                    mark += 1;
+                    arr.swap(i, mark);
+                }
+            }
+            arr.swap(start, mark);
+
+            if mark <= k {
+                start = mark + 1;
+            } else {
+                end = mark
+            }
+        }
+        arr[0..k].to_vec()
+    }
+}
diff --git a/lcof/面试题40. 最小的k个数/Solution.ts b/lcof/面试题40. 最小的k个数/Solution.ts
@@ -0,0 +1,24 @@
+function getLeastNumbers(arr: number[], k: number): number[] {
+    let start = 0;
+    let end = arr.length;
+    while (start < end && end > k) {
+        const index = start + Math.floor(Math.random() * (end - start));
+        [arr[start], arr[index]] = [arr[index], arr[start]];
+        const num = arr[start];
+        let mark = start;
+        for (let i = start + 1; i < end; i++) {
+            if (arr[i] < num) {
+                mark++;
+                [arr[i], arr[mark]] = [arr[mark], arr[i]];
+            }
+        }
+        [arr[start], arr[mark]] = [arr[mark], arr[start]];
+
+        if (mark >= k) {
+            end = mark;
+        } else {
+            start = mark + 1;
+        }
+    }
+    return arr.slice(0, k);
+}
diff --git a/lcof/面试题41. 数据流中的中位数/README.md b/lcof/面试题41. 数据流中的中位数/README.md
@@ -209,32 +209,34 @@ private:
 
 ```ts
 class MedianFinder {
-    public arr: number[] = [];
+    private nums: number[];
 
-    constructor() {}
+    constructor() {
+        this.nums = [];
+    }
 
     addNum(num: number): void {
-        const { arr } = this;
+        const { nums } = this;
         let l = 0;
-        let r = arr.length - 1;
-        while (l <= r) {
-            const mid = (l + r) >> 1;
-            if (arr[mid] < num) {
+        let r = nums.length;
+        while (l < r) {
+            const mid = (l + r) >>> 1;
+            if (nums[mid] < num) {
                 l = mid + 1;
             } else {
-                r = mid - 1;
+                r = mid;
             }
         }
-        arr.splice(l, 0, num);
+        nums.splice(l, 0, num);
     }
 
     findMedian(): number {
-        const { arr } = this;
-        const n = arr.length;
-        if (n % 2 === 0) {
-            return (arr[n >> 1] + arr[(n >> 1) - 1]) / 2;
+        const { nums } = this;
+        const n = nums.length;
+        if ((n & 1) === 1) {
+            return nums[n >> 1];
         }
-        return arr[n >> 1];
+        return (nums[n >> 1] + nums[(n >> 1) - 1]) / 2;
     }
 }
 
@@ -250,7 +252,7 @@ class MedianFinder {
 
 ```rust
 struct MedianFinder {
-    arr: Vec<i32>,
+    nums: Vec<i32>,
 }
 
 /**
@@ -260,31 +262,29 @@ struct MedianFinder {
 impl MedianFinder {
     /** initialize your data structure here. */
     fn new() -> Self {
-        MedianFinder {
-            arr: vec![]
-        }
+        Self { nums: Vec::new() }
     }
 
     fn add_num(&mut self, num: i32) {
         let mut l = 0;
-        let mut r = self.arr.len();
+        let mut r = self.nums.len();
         while l < r {
             let mid = l + r >> 1;
-            if self.arr[mid] < num {
+            if self.nums[mid] < num {
                 l = mid + 1;
             } else {
                 r = mid;
             }
         }
-        self.arr.splice(l..l, [num]);
+        self.nums.insert(l, num);
     }
 
     fn find_median(&self) -> f64 {
-        let n = self.arr.len();
-        match n % 2 == 0 {
-            true => f64::from(self.arr[n >> 1] + self.arr[(n >> 1) - 1]) / 2.0,
-            false => f64::from(self.arr[n >> 1]),
+        let n = self.nums.len();
+        if (n & 1) == 1 {
+            return f64::from(self.nums[n >> 1]);
         }
+        f64::from(self.nums[n >> 1] + self.nums[(n >> 1) - 1]) / 2.0
     }
 }
 
diff --git a/lcof/面试题41. 数据流中的中位数/Solution.rs b/lcof/面试题41. 数据流中的中位数/Solution.rs
@@ -1,5 +1,5 @@
 struct MedianFinder {
-    arr: Vec<i32>,
+    nums: Vec<i32>,
 }
 
 /**
@@ -9,31 +9,29 @@ struct MedianFinder {
 impl MedianFinder {
     /** initialize your data structure here. */
     fn new() -> Self {
-        MedianFinder {
-            arr: vec![]
-        }
+        Self { nums: Vec::new() }
     }
 
     fn add_num(&mut self, num: i32) {
         let mut l = 0;
-        let mut r = self.arr.len();
+        let mut r = self.nums.len();
         while l < r {
             let mid = l + r >> 1;
-            if self.arr[mid] < num {
+            if self.nums[mid] < num {
                 l = mid + 1;
             } else {
                 r = mid;
             }
         }
-        self.arr.splice(l..l, [num]);
+        self.nums.insert(l, num);
     }
 
     fn find_median(&self) -> f64 {
-        let n = self.arr.len();
-        match n % 2 == 0 {
-            true => f64::from(self.arr[n >> 1] + self.arr[(n >> 1) - 1]) / 2.0,
-            false => f64::from(self.arr[n >> 1]),
+        let n = self.nums.len();
+        if (n & 1) == 1 {
+            return f64::from(self.nums[n >> 1]);
         }
+        f64::from(self.nums[n >> 1] + self.nums[(n >> 1) - 1]) / 2.0
     }
 }
 
diff --git a/lcof/面试题41. 数据流中的中位数/Solution.ts b/lcof/面试题41. 数据流中的中位数/Solution.ts
@@ -1,30 +1,32 @@
 class MedianFinder {
-    public arr: number[] = [];
+    private nums: number[];
 
-    constructor() {}
+    constructor() {
+        this.nums = [];
+    }
 
     addNum(num: number): void {
-        const { arr } = this;
+        const { nums } = this;
         let l = 0;
-        let r = arr.length - 1;
-        while (l <= r) {
-            const mid = (l + r) >> 1;
-            if (arr[mid] < num) {
+        let r = nums.length;
+        while (l < r) {
+            const mid = (l + r) >>> 1;
+            if (nums[mid] < num) {
                 l = mid + 1;
             } else {
-                r = mid - 1;
+                r = mid;
             }
         }
-        arr.splice(l, 0, num);
+        nums.splice(l, 0, num);
     }
 
     findMedian(): number {
-        const { arr } = this;
-        const n = arr.length;
-        if (n % 2 === 0) {
-            return (arr[n >> 1] + arr[(n >> 1) - 1]) / 2;
+        const { nums } = this;
+        const n = nums.length;
+        if ((n & 1) === 1) {
+            return nums[n >> 1];
         }
-        return arr[n >> 1];
+        return (nums[n >> 1] + nums[(n >> 1) - 1]) / 2;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`struct MedianFinder {`
`2`		`- arr: Vec<i32>,`
	`2`	`+ nums: Vec<i32>,`
`3`	`3`	`}`
`4`	`4`
`5`	`5`	`/**`
`@@ -9,31 +9,29 @@ struct MedianFinder {`
`9`	`9`	`impl MedianFinder {`
`10`	`10`	`/** initialize your data structure here. */`
`11`	`11`	`fn new() -> Self {`
`12`		`- MedianFinder {`
`13`		`- arr: vec![]`
`14`		`- }`
	`12`	`+ Self { nums: Vec::new() }`
`15`	`13`	`}`
`16`	`14`
`17`	`15`	`fn add_num(&mut self, num: i32) {`
`18`	`16`	`let mut l = 0;`
`19`		`- let mut r = self.arr.len();`
	`17`	`+ let mut r = self.nums.len();`
`20`	`18`	`while l < r {`
`21`	`19`	`let mid = l + r >> 1;`
`22`		`- if self.arr[mid] < num {`
	`20`	`+ if self.nums[mid] < num {`
`23`	`21`	`l = mid + 1;`
`24`	`22`	`} else {`
`25`	`23`	`r = mid;`
`26`	`24`	`}`
`27`	`25`	`}`
`28`		`- self.arr.splice(l..l, [num]);`
	`26`	`+ self.nums.insert(l, num);`
`29`	`27`	`}`
`30`	`28`
`31`	`29`	`fn find_median(&self) -> f64 {`
`32`		`- let n = self.arr.len();`
`33`		`- match n % 2 == 0 {`
`34`		`- true => f64::from(self.arr[n >> 1] + self.arr[(n >> 1) - 1]) / 2.0,`
`35`		`- false => f64::from(self.arr[n >> 1]),`
	`30`	`+ let n = self.nums.len();`
	`31`	`+ if (n & 1) == 1 {`
	`32`	`+ return f64::from(self.nums[n >> 1]);`
`36`	`33`	`}`
	`34`	`+ f64::from(self.nums[n >> 1] + self.nums[(n >> 1) - 1]) / 2.0`
`37`	`35`	`}`
`38`	`36`	`}`
`39`	`37`