Implement partial_sort_unstable for slice

Signed-off-by: tison <wander4096@gmail.com>

Author: tisonkun

library/core/src/slice/mod.rs

@@ -3242,6 +3242,50 @@ impl<T> [T] {
         sort::unstable::sort(self, &mut |a, b| f(a).lt(&f(b)));
     }
 
+    /// Partially sorts the slice in ascending order **without** preserving the initial order
+    /// of equal elements.
+    #[unstable(feature = "slice_partial_sort_unstable", issue = "149046")]
+    #[inline]
+    pub fn partial_sort_unstable<R>(&mut self, range: R)
+    where
+        T: Ord,
+        R: RangeBounds<usize>,
+    {
+        self.partial_sort_unstable_by(range, T::cmp);
+    }
+
+    /// Partially sorts the slice in ascending order with a comparison function, **without**
+    /// preserving the initial order of equal elements.
+    #[unstable(feature = "slice_partial_sort_unstable", issue = "149046")]
+    #[inline]
+    pub fn partial_sort_unstable_by<F, R>(&mut self, range: R, mut compare: F)
+    where
+        F: FnMut(&T, &T) -> Ordering,
+        R: RangeBounds<usize>,
+    {
+        let len = self.len();
+        let Range { start, end } = range(range, ..len);
+
+        sort::select::partition_at_index(self, start, |a: &T, b: &T| compare(a, b) == Less);
+        sort::select::partition_at_index(&mut self[start..], end - start, |a: &T, b: &T| {
+            compare(a, b) == Less
+        });
+        sort::unstable::sort(&mut self[start..end], &mut |a, b| compare(a, b) == Less);
+    }
+
+    /// Partially sorts the slice in ascending order with a key extraction function, **without**
+    /// preserving the initial order of equal elements.
+    #[unstable(feature = "slice_partial_sort_unstable", issue = "149046")]
+    #[inline]
+    pub fn partial_sort_unstable_by_key<K, F, R>(&mut self, range: R, mut f: F)
+    where
+        F: FnMut(&T) -> K,
+        K: Ord,
+        R: RangeBounds<usize>,
+    {
+        self.partial_sort_unstable_by(range, |a, b| f(a).cmp(&f(b)));
+    }
+
     /// Reorders the slice such that the element at `index` is at a sort-order position. All
     /// elements before `index` will be `<=` to this value, and all elements after will be `>=` to
     /// it.