Skip find_existing_run call if head and tail pairs sorted differently

This would help to avoid running comparator for all elements
when user pushed an element to end of sorted Vec, breaking order only in last element.

Author: AngelicosPhosphoros

library/core/src/slice/sort/unstable/mod.rs

@@ -63,19 +63,25 @@ where
     F: FnMut(&T, &T) -> bool,
 {
     let len = v.len();
-    let (run_len, was_reversed) = find_existing_run(v, is_less);
+    // Skip `find_existing_run` if head and tail sorted differently
+    // because we are interested only if the whole slice is sorted.
+    // This should skip in cases when user tries to sort a vector after single call to push.
+    let check_existing_run = len < 3 || is_less(&v[0], &v[1]) == is_less(&v[len - 2], &v[len - 1]);
+    if check_existing_run {
+        let (run_len, was_reversed) = find_existing_run(v, is_less);
 
-    // SAFETY: find_existing_run promises to return a valid run_len.
-    unsafe { intrinsics::assume(run_len <= len) };
+        // SAFETY: find_existing_run promises to return a valid run_len.
+        unsafe { intrinsics::assume(run_len <= len) };
 
-    if run_len == len {
-        if was_reversed {
-            v.reverse();
-        }
+        if run_len == len {
+            if was_reversed {
+                v.reverse();
+            }
 
-        // It would be possible to a do in-place merging here for a long existing streak. But that
-        // makes the implementation a lot bigger, users can use `slice::sort` for that use-case.
-        return;
+            // It would be possible to a do in-place merging here for a long existing streak. But that
+            // makes the implementation a lot bigger, users can use `slice::sort` for that use-case.
+            return;
+        }
     }
 
     // Limit the number of imbalanced partitions to `2 * floor(log2(len))`.