Move resorting to algos

Author: phofl

pandas/core/algorithms.py

@@ -2115,3 +2115,28 @@ def sort_mixed(values):
         np.putmask(new_codes, mask, na_sentinel)
 
     return ordered, ensure_platform_int(new_codes)
+
+
+def resort_union_after_inputs(union_values, lvals, rvals) -> np.ndarray:
+    """
+    Elements from union_values are resorted after the order of
+    lvals and then rvals, if element is not in lvals. All occurrences
+    are placed at the spot of the first occurrence of this element.
+
+    Parameters
+    ----------
+    union_values: np.array which is a sorted union of lvals and rvals
+    lvals: np.ndarray of the left values which is ordered in front.
+    rvals: np.ndarray of the right values ordered after lvals.
+
+    Returns
+    -------
+    np.ndarray containing the resorted values from union_values
+    """
+    indexer = []
+    counts = dict(zip(*np.unique(union_values, return_counts=True)))
+    unique_array = unique(np.append(lvals, rvals))
+    # Create indexer to resort result
+    for i, value in enumerate(unique_array):
+        indexer += [i] * counts[value]
+    return unique_array.take(indexer)

pandas/core/indexes/base.py

@@ -2659,11 +2659,8 @@ def _union(self, other, sort):
         rvals = other._values
 
         try:
-            if sort is None and self.is_monotonic and other.is_monotonic:
-                result = self._outer_indexer(lvals, rvals)[0]
-            else:
-                # We calculate the sorted union and resort it afterwards
-                result = self._outer_indexer(np.sort(lvals), np.sort(rvals))
+            # If one of both is not monotonic, we resort it afterwards
+            result = self._outer_indexer(np.sort(lvals), np.sort(rvals))[0]
         except TypeError:
             # incomparable objects
             result = list(lvals)
@@ -2674,13 +2671,8 @@ def _union(self, other, sort):
             result = Index(result)._values  # do type inference here
         else:
             if sort is False or not self.is_monotonic or not other.is_monotonic:
-                indexer = []
-                counts = dict(zip(*np.unique(result[0], return_counts=True)))
-                unique_array = algos.unique(np.append(lvals, rvals))
-                # Create indexer to resort result
-                for i, value in enumerate(unique_array):
-                    indexer += [i] * counts[value]
-                result = unique_array.take(indexer)
+                result = algos.resort_union_after_inputs(result, lvals, rvals)
+
         if sort is None and (not self.is_monotonic or not other.is_monotonic):
             try:
                 result = algos.safe_sort(result)