goulag_sort/goulagsort.py

@@ -1,71 +1,81 @@
-def send_to_goulag(main_list: list) -> list:
+def send_to_goulag(input_list:list)-> list :
-    if not main_list:
+    """Sorts a list of numbers using the unique "Goulag Sort" method.
-        return [] # Se a lista de entrada está vazia, retorna vazio
 
-    # Se a lista tem 1 ou 0 elementos, ela já está ordenada
+    This algorithm processes a list of numbers through a distinctive iterative and
-    if len(main_list) <= 1:
+    recursive procedure, inspired by the "Stalin Sort" concept. Here's how it operates:
-        return main_list
 
-    filtered_list = []
+    1.  **Iterative Filtering:** It iterates through the main list. If an element
-    gulag_list = []
+        is found to be greater than its subsequent element, the subsequent element
+        is moved to a temporary holding list (`temp`). The main list then continues
+        with the remaining elements.
 
-    # O primeiro elemento sempre vai para a filtered_list como ponto de partida
+    2.  **Recursive Processing of Held Items:** If the `temp` list contains more than
-    filtered_list.append(main_list[0])
+        one item, the `send_to_goulag` algorithm recursively processes `temp`. This
+        filtering and holding process continues until the sub-list contains a single
+        item or becomes empty.
 
-    # Percorre o restante da lista original (a partir do segundo elemento)
+    3.  **Partial Re-insertion:** After the recursive calls (or if `temp` was empty/single-item),
-    # com um único ponteiro 'i'
+        the algorithm attempts to re-insert the elements from `temp` back into the main list.
-    for i in range(1, len(main_list)):
+        This re-insertion is performed by finding a suitable position where the held item
-        current_item = main_list[i]
+        is less than the current element in the main list, maintaining a partial order.
-        last_in_filtered = filtered_list[-1] # Pega o último item já colocado na filtered_list
 
-        if current_item >= last_in_filtered:
+    4.  **Final Appending:** Any remaining elements in `temp` that were not re-inserted
-            # Se o item atual mantém a ordem com o que já foi filtrado, adicione-o
+        into the middle of the list are then appended to the end of the main list.
-            filtered_list.append(current_item)
-        else:
-            # Se o item atual quebra a ordem, ele é "rejeitado" para o gulag
-            gulag_list.append(current_item)
 
-    if len(gulag_list) > 1:
+    For a more detailed step-by-step explanation of the algorithm's flow, please refer to:
-        gulag_list = send_to_goulag(gulag_list)
+    :ref:`goulag_sort_detailed_explanation`.
-
-    filtered_list = merge_sorted_lists_efficient(filtered_list,gulag_list)
-
-    return filtered_list
-
-
-def merge_sorted_lists_efficient(list1: list, list2: list) -> list:
-    """
-    Mescla duas listas ordenadas de forma eficiente, criando uma nova lista resultado.
-    Evita as operações custosas de insert/pop no meio das listas.
 
     Args:
-        list1: A primeira lista ordenada.
+        input_list (list): The list of numbers to be processed and sorted.
-        list2: A segunda lista ordenada.
+                           This list will be modified **in-place**.
 
     Returns:
-        Uma NOVA lista contendo todos os elementos de list1 e list2 mesclados e ordenados.
+        list: The list after being processed by the Goulag Sort algorithm. The result
+              is an ordered list.
+
+    Examples:
+        >>> from goulag_sort import send_to_goulag
+        >>> my_list = [5, 2, 8, 1, 9, 4]
+        >>> send_to_goulag(my_list)
+        [1, 2, 4, 5, 8, 9]
+
+        >>> empty_list = []
+        >>> send_to_goulag(empty_list)
+        []
     """
-    merged_list = []
-    ptr1 = 0  # Ponteiro para list1
-    ptr2 = 0  # Ponteiro para list2
 
-    # Enquanto houver elementos em ambas as listas para comparar
+
-    while ptr1 < len(list1) and ptr2 < len(list2):
+    idx = 0
-        if list1[ptr1] <= list2[ptr2]:  # Note o <= para estabilidade (mantém ordem de iguais)
+    temp = []
-            merged_list.append(list1[ptr1])
+    while True:
-            ptr1 += 1
+
+        if not input_list:
+            return []
+
+        while idx < len(input_list) - 1:
+            if input_list[idx] > input_list[idx + 1]:
+                temp.append(input_list[idx + 1])
+                # pop(idx+1) é uma operação O(N) no pior caso
+                input_list.pop(idx + 1)
             else:
-            merged_list.append(list2[ptr2])
+                idx += 1
-            ptr2 += 1
 
-    # Adicionar quaisquer elementos restantes de list1 (se houver)
+        # Chamada recursiva (pode adicionar complexidade se for muito frequente)
-    while ptr1 < len(list1):
+        if len(temp) > 1:
-        merged_list.append(list1[ptr1])
+            temp = send_to_goulag(temp)
-        ptr1 += 1
 
-    # Adicionar quaisquer elementos restantes de list2 (se houver)
+        idx = 0
-    while ptr2 < len(list2):
+        # Loop para reinserir elementos de 'temp' na lista principal
-        merged_list.append(list2[ptr2])
+        while idx < len(input_list):
-        ptr2 += 1
+            if temp and input_list[idx] > temp[0]:
+                # Inserção no meio da lista input_list[idx:idx] = temp é O(N) no pior caso
+                input_list[idx:idx] = temp
+                temp.clear()
+                break
+            idx += 1
+            if len(temp) == 0:
+                return input_list
 
-    return merged_list
+        if temp:
+            input_list.extend(temp)  # extend é O(k) onde k é o tamanho de temp
+            temp.clear()