Changeset 96361 in vbox

Timestamp:

Aug 19, 2022 8:55:32 PM (2 years ago)

Author:

vboxsync

Message:

iprt/nocrt/algorithm: Just use shell sort for the std::sort implementation for now. bugref:10261

File:

• trunk/include/iprt/nocrt/algorithm (modified) (1 diff)

trunk/include/iprt/nocrt/algorithm

@@ -37 +37 @@
 namespace std
 {
+    /**
+     * Swap the values pointed to by the two references.
+     */
+    template<typename a_Type>
+    void swap(a_Type &a_rObj1, a_Type &a_rObj2)
+    {
+        a_Type Tmp(a_rObj1);
+        a_rObj1 = a_rObj2;
+        a_rObj2 = Tmp;
+    }
+
+    /**
+     * Swap the values pointed to by two forward iterators.
+     */
+    template<typename a_ForwardIt1, typename a_ForwardIt2>
+    void iter_swap(a_ForwardIt1 a_It1, a_ForwardIt2 a_It2)
+    {
+        swap(*a_It1, *a_It2);
+    }
+
     template<typename a_RandomIt>
-    void sort(a_RandomIt a_ItBegin, a_RandomIt a_ItEnd);
+    void sort(a_RandomIt a_ItBegin, a_RandomIt a_ItEnd)
+    {
+        /* Note! Using shell sort here because it's tiny and we've got code for it. */
+        /** @todo replace with faster code.   */
 
-    template<typename a_RandomIt, typename a_Compare>
-    void sort(a_RandomIt a_ItBegin, a_RandomIt a_ItEnd, a_Compare);
+        /* Anything worth sorting? */
+        std::size_t const cElements = a_ItEnd - a_ItBegin;
+        if (cElements >= 1)
+        {
+            /* Loop on decreasing gap, ending with 1: */
+            std::size_t cGap = (cElements + 1) / 2;
+            while (cGap > 0)
+            {
+                /* Iterate from cGap till the end: */
+                for (std::size_t i = cGap; i < cElements; i++)
+                {
+                    /* Find the best suitable location for the item at 'i' comparing
+                       backwards in steps of 'cGap', swapping the item at 'i' with the
+                       one at '-cGap*j' if it's smaller, stopping if it's larger.
+
+                       Note! Original algorithm would make a copy of the item, this version
+                             avoids extra copies of sorted items at the cost of extra copies
+                             when dealing with unsorted ones a small cGaps values. */
+                    a_RandomIt ItCur = a_ItBegin + i;
+                    size_t     j     = i;
+                    do
+                    {
+                        j -= cGap;
+                        a_RandomIt ItAtGap = a_ItBegin + j;
+                        if (*ItAtGap < *ItCur)
+                            break;
+                        std::iter_swap(ItAtGap, ItCur);
+                        ItCur = ItAtGap;
+                    } while (j >= cGap);
+                }
+
+                /* This does not generate the most optimal gap sequence, but it has the
+                   advantage of being simple and avoid floating point. */
+                cGap /= 2;
+            }
+        }
+    }
+
+    template<typename a_RandomIt, typename a_FnCompareType>
+    void sort(a_RandomIt a_ItBegin, a_RandomIt a_ItEnd, a_FnCompareType a_fnComp)
+    {
+        /* Note! Using shell sort here because it's tiny and we've got code for it. */
+        /** @todo replace with faster code.   */
+
+        /* Anything worth sorting? */
+        std::size_t const cElements = a_ItEnd - a_ItBegin;
+        if (cElements >= 1)
+        {
+            /* Loop on decreasing gap, ending with 1: */
+            std::size_t cGap = (cElements + 1) / 2;
+            while (cGap > 0)
+            {
+                /* Iterate from cGap till the end: */
+                for (std::size_t i = cGap; i < cElements; i++)
+                {
+                    /* Find the best suitable location for the item at 'i' comparing
+                       backwards in steps of 'cGap', swapping the item at 'i' with the
+                       one at '-cGap*j' if it's smaller, stopping if it's larger.
+
+                       Note! Original algorithm would make a copy of the item, this version
+                             avoids extra copies of sorted items at the cost of extra copies
+                             when dealing with unsorted ones a small cGaps values. */
+                    a_RandomIt ItCur = a_ItBegin + i;
+                    size_t     j     = i;
+                    do
+                    {
+                        j -= cGap;
+                        a_RandomIt ItAtGap = a_ItBegin + j;
+                        if (a_fnComp(*ItAtGap, *ItCur))
+                            break;
+                        std::iter_swap(ItAtGap, ItCur);
+                        ItCur = ItAtGap;
+                    } while (j >= cGap);
+                }
+
+                /* This does not generate the most optimal gap sequence, but it has the
+                   advantage of being simple and avoid floating point. */
+                cGap /= 2;
+            }
+        }
+    }
 
 }