all tasks

Task/Sorting-algorithms-Quicksort/Modula-2/sorting-algorithms-quicksort-1.mod2

@@ -0,0 +1,11 @@
+(*#####################*)
+ DEFINITION MODULE QSORT;
+(*#####################*)
+
+FROM SYSTEM IMPORT ADDRESS;
+
+TYPE CmpFuncPtrs = PROCEDURE(ADDRESS, ADDRESS):INTEGER;
+
+ PROCEDURE QuickSortPtrs(VAR Array:ARRAY OF ADDRESS; N:CARDINAL;
+                         Compare:CmpFuncPtrs);
+END QSORT.

Task/Sorting-algorithms-Quicksort/Modula-2/sorting-algorithms-quicksort-2.mod2

@@ -0,0 +1,127 @@
+(*##########################*)
+ IMPLEMENTATION MODULE QSORT;
+(*##########################*)
+
+FROM SYSTEM    IMPORT ADDRESS;
+
+CONST SmallPartition  = 9;
+
+(*
+NOTE
+        1.Reference on QuickSort: "Implementing Quicksort Programs", Robert
+          Sedgewick, Communications of the ACM, Oct 78, v21 #10.
+*)
+
+(*==============================================================*)
+ PROCEDURE QuickSortPtrs(VAR Array:ARRAY OF ADDRESS; N:CARDINAL;
+                         Compare:CmpFuncPtrs);
+(*==============================================================*)
+
+         (*-----------------------------*)
+          PROCEDURE Swap(VAR A,B:ADDRESS);
+         (*-----------------------------*)
+
+         VAR  temp :ADDRESS;
+
+         BEGIN
+
+         temp := A; A := B; B := temp;
+
+         END Swap;
+
+         (*-------------------------------*)
+          PROCEDURE TstSwap(VAR A,B:ADDRESS);
+         (*-------------------------------*)
+
+         VAR  temp   :ADDRESS;
+
+         BEGIN
+
+         IF Compare(A,B) > 0 THEN
+            temp := A; A := B; B := temp;
+         END;
+
+         END TstSwap;
+
+         (*--------------*)
+          PROCEDURE Isort;
+         (*--------------*)
+         (*
+                 Insertion sort.
+         *)
+
+         VAR  i,j    :CARDINAL;
+              temp   :ADDRESS;
+
+         BEGIN
+
+         IF N < 2 THEN RETURN END;
+
+         FOR i := N-2 TO 0 BY -1 DO
+            IF Compare(Array[i],Array[i+1]) > 0 THEN
+               temp := Array[i];
+               j := i+1;
+               REPEAT
+                  Array[j-1] := Array[j];
+                  INC(j);
+               UNTIL (j = N) OR (Compare(Array[j],temp) >= 0);
+               Array[j-1] := temp;
+            END;
+         END;
+
+         END Isort;
+
+         (*----------------------------------*)
+          PROCEDURE Quick(left,right:CARDINAL);
+         (*----------------------------------*)
+
+         VAR
+              i,j,
+              second     :CARDINAL;
+              Partition  :ADDRESS;
+
+         BEGIN
+
+         IF right > left THEN
+            i := left; j := right;
+
+            Swap(Array[left],Array[(left+right) DIV 2]);
+
+            second := left+1;                          (* insure 2nd element is in   *)
+            TstSwap(Array[second], Array[right]);      (* the lower part, last elem  *)
+            TstSwap(Array[left], Array[right]);        (* in the upper part          *)
+            TstSwap(Array[second], Array[left]);       (* THUS, only one test is     *)
+                                                       (* needed in repeat loops     *)
+            Partition := Array[left];
+
+            LOOP
+               REPEAT INC(i) UNTIL Compare(Array[i],Partition) >= 0;
+               REPEAT DEC(j) UNTIL Compare(Array[j],Partition) <= 0;
+               IF j < i THEN
+                  EXIT
+               END;
+               Swap(Array[i],Array[j]);
+            END; (*loop*)
+            Swap(Array[left],Array[j]);
+
+            IF (j > 0) AND (j-1-left >= SmallPartition) THEN
+               Quick(left,j-1);
+            END;
+            IF right-i >= SmallPartition THEN
+               Quick(i,right);
+            END;
+         END;
+
+         END Quick;
+
+ BEGIN (* QuickSortPtrs --------------------------------------------------*)
+
+IF N > SmallPartition THEN              (* won't work for 2 elements *)
+   Quick(0,N-1);
+END;
+
+Isort;
+
+END QuickSortPtrs;
+
+END QSORT.