renew project

Author: linjing-lab

Diff for: README.md

@@ -96,6 +96,7 @@ explain:
 By the way, I didn't complete all the iterative data types, in order to develop a more targeted scenario. If you are **interested** in other iterative data types, please add them in the `convert` function of the `_utils.py` file, for example: bytes, bytearray, range, zip. If you need to deal with `dict_keys`, `dict_values`, `dict_items`, please use `list()` to convert the variables of these data types before using any method of sortingx.
 
 - [sortingx-1.2.2](https://github.com/linjing-lab/sorting-algorithms/tree/v1.2.2) is the package that support `range`, `zip`, `dict_keys`, `dict_values`, `dict_items` additionally, you can choose what suitable data you want to input.
+- [sortingx-1.2.3](https://github.com/linjing-lab/sorting-algorithms/tree/v1.2.3) is the package that corrected the situation where elements are equal in `compare`, support more input data, like data as `[['Jack', (98, 100)], ['Bob', (98, 99)], ['Jessi', (98, 97)]]` and key as `lambda x: x[1][0]`.
 
 ## LICENSE
 

Diff for: README_release.md

@@ -11,5 +11,6 @@
 |v1.2.0|`pip install sortingx==1.2.0`|Optimize Generate Function's Kernel|√|
 |v1.2.1|`pip install sortingx==1.2.1`|Delete Core Function to Make Builtin First|√|
 |v1.2.2|`pip install sortingx==1.2.2`|Change Convert Function to Make it More Robust|√|
+|v1.2.3|`pip install sortingx==1.2.3`|Add Verify Function to Solve Comparison of Equal|√|
 
 </div>

Diff for: sortingx/__init__.py

@@ -16,6 +16,6 @@
 
 from .sorting import bubble, insert, shell, heap, quick, merge, __all__
 
-__version__ = '1.2.2'
+__version__ = '1.2.3'
 
 assert sys.version_info >= (3, 7, 0)

Diff for: sortingx/_utils.py

@@ -25,6 +25,15 @@ def generate(__iterable: List[_T], key: Optional[Callable[[_T], SupportsRichComp
     compare: List[_T] = list(map(key, __iterable)) if key != None else __iterable
     return compare
 
+# Verify Elements Are Equal before Comparison.
+def verify(compare: List[_T]) -> bool:
+    '''
+    :param compare: List[_T], list generated by `generate` with builtin api named `map`.
+
+    :return: bool value indicated whether to enter comparison.
+    '''
+    return compare.count(compare[0]) == len(compare)
+
 # Uniformly Convert `Iterable` into `List`: Facilitate the Execution of Sorting Algorithms.
 def convert(__iterable: Iterable[_T]) -> List[_T]:
     '''

Diff for: sortingx/sorting.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ._utils import generate, convert
+from ._utils import generate, convert, verify
 from ._typing import Iterable, Callable, Optional, _T, SupportsRichComparison, List
 
 __all__ = ["bubble", "insert", "shell", "heap", "quick", "merge"]
@@ -27,16 +27,17 @@ def bubble(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichCo
     '''
     __iterable: List[_T] = convert(__iterable)
     compare: List[_T] = generate(__iterable, key)
-    for i in range(len(__iterable) - 1):
-        flag: bool = False # early stop by adding a bool value named flag
-        for j in range(len(__iterable) - i - 1):
-            if (compare[j] < compare[j + 1] if reverse else compare[j] > compare[j+1]):
-                __iterable[j], __iterable[j + 1] = __iterable[j + 1], __iterable[j]
-                if key != None:
-                    compare[j], compare[j + 1] = compare[j + 1], compare[j]
-                flag: bool = True
-        if not flag:
-            break
+    if compare and not verify(compare):
+        for i in range(len(__iterable) - 1):
+            flag: bool = False # early stop by adding a bool value named flag
+            for j in range(len(__iterable) - i - 1):
+                if (compare[j] < compare[j + 1] if reverse else compare[j] > compare[j+1]):
+                    __iterable[j], __iterable[j + 1] = __iterable[j + 1], __iterable[j]
+                    if key != None:
+                        compare[j], compare[j + 1] = compare[j + 1], compare[j]
+                    flag: bool = True
+            if not flag:
+                break
     return __iterable
 
 def insert(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichComparison]]=None, reverse: bool=False) -> List[_T]:
@@ -49,24 +50,25 @@ def insert(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichCo
     '''
     __iterable: List[_T] = convert(__iterable)
     compare: List[_T] = generate(__iterable, key)
-    for index in range(1, len(__iterable)):
-        keyc: _T = compare[index]
-        keya: _T = __iterable[index]
-        low : int = 0
-        high: int = index - 1
-        while low <= high: # sequence conforming to monotonicity
-            mid: int = (low + high) // 2
-            if (keyc < compare[mid] if reverse else keyc > compare[mid]):
-                low: int = mid + 1
-            else:
-                high: int = mid - 1
-        for pre in range(index, low, -1): # from back to front
-            __iterable[pre] = __iterable[pre - 1]
+    if compare and not verify(compare):
+        for index in range(1, len(__iterable)):
+            keyc: _T = compare[index]
+            keya: _T = __iterable[index]
+            low : int = 0
+            high: int = index - 1
+            while low <= high: # sequence conforming to monotonicity
+                mid: int = (low + high) // 2
+                if (keyc < compare[mid] if reverse else keyc > compare[mid]):
+                    low: int = mid + 1
+                else:
+                    high: int = mid - 1
+            for pre in range(index, low, -1): # from back to front
+                __iterable[pre] = __iterable[pre - 1]
+                if key != None:
+                    compare[pre] = compare[pre - 1]
+            __iterable[low] = keya
             if key != None:
-                compare[pre] = compare[pre - 1]
-        __iterable[low] = keya
-        if key != None:
-            compare[low] = keyc
+                compare[low] = keyc
     return __iterable
 
 def shell(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichComparison]]=None, reverse: bool=False) -> List[_T]:
@@ -79,19 +81,20 @@ def shell(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichCom
     '''
     __iterable: List[_T] = convert(__iterable)
     compare: List[_T] = generate(__iterable, key)
-    length: int = len(__iterable)
-    gap: int = 1
-    while gap < length / 3:
-        gap: int = int(3 * gap + 1)
-    while gap >= 1:
-        for index in range(gap, length):
-            next: int = index
-            while next >= gap and (compare[next - gap] < compare[next] if reverse else compare[next - gap] > compare[next]):
-                __iterable[next], __iterable[next - gap] = __iterable[next - gap], __iterable[next]
-                if key != None:
-                    compare[next], compare[next - gap] = compare[next - gap], compare[next]
-                next -= gap
-        gap: int = int(gap / 3)
+    if compare and not verify(compare):
+        length: int = len(__iterable)
+        gap: int = 1
+        while gap < length / 3:
+            gap: int = int(3 * gap + 1)
+        while gap >= 1:
+            for index in range(gap, length):
+                next: int = index
+                while next >= gap and (compare[next - gap] < compare[next] if reverse else compare[next - gap] > compare[next]):
+                    __iterable[next], __iterable[next - gap] = __iterable[next - gap], __iterable[next]
+                    if key != None:
+                        compare[next], compare[next - gap] = compare[next - gap], compare[next]
+                    next -= gap
+            gap: int = int(gap / 3)
     return __iterable
 
 def heap(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichComparison]]=None, reverse: bool=False) -> List[_T]:
@@ -121,15 +124,15 @@ def build(root: int, end: int) -> None:
             if key != None:
                 compare[root], compare[piv] = compare[piv], compare[root]
             build(piv, end)
-    
-    length: int = len(__iterable)
-    for root in range(length // 2 - 1 , -1, -1):
-        build(root, length)
-    for end in range(length - 1, 0, -1):
-        __iterable[0], __iterable[end] = __iterable[end], __iterable[0]
-        if key != None:
-            compare[0], compare[end] = compare[end], compare[0]
-        build(0, end)
+    if compare and not verify(compare):
+        length: int = len(__iterable)
+        for root in range(length // 2 - 1 , -1, -1):
+            build(root, length)
+        for end in range(length - 1, 0, -1):
+            __iterable[0], __iterable[end] = __iterable[end], __iterable[0]
+            if key != None:
+                compare[0], compare[end] = compare[end], compare[0]
+            build(0, end)
     return __iterable
 
 def quick(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichComparison]]=None, reverse: bool=False) -> List[_T]:
@@ -168,7 +171,8 @@ def partition(l: int, r: int) -> int:
         if key != None:
             compare[index + 1], compare[r] = compare[r], compare[index + 1]
         return index + 1
-    solve(0, len(__iterable) - 1)
+    if compare and not verify(compare):
+        solve(0, len(__iterable) - 1)
     return __iterable
 
 def merge(__iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsRichComparison]]=None, reverse: bool=False) -> List[_T]:
@@ -225,5 +229,6 @@ def solve() -> None:
                     merg(low, mid, high)
                 low += 2 * i
             i *= 2
-    solve()
+    if compare and not verify(compare):
+        solve()
     return __iterable

Diff for: tests/test_equal.py

@@ -0,0 +1,8 @@
+import sortingx
+
+data1 = [['Jack', (98, 100)], ['Bob', (98, 99)], ['Jessi', (98, 97)]]
+data2 = [['Jack', (98.1, 100)], ['Bob', (98.1, 99)], ['Jessi', (98.1, 97)]]
+data3 = [['Jack', (98.11, 100)], ['Bob', (98.10000000000, 99)], ['Jessi', (98.1100000000000000, 97)]]
+
+print(sortingx.bubble(data1, key=lambda x: x[1][0], reverse=True))
+print(sorted(data1, key=lambda x: x[1][0], reverse=True))