Task 107

Author: CARTOON01

107-quick_sort_hoare.c

@@ -1,95 +1,72 @@
 #include "sort.h"
-
-void swap_ints(int *a, int *b);
-int hoare_partition(int *array, size_t size, int left, int right);
-void hoare_sort(int *array, size_t size, int left, int right);
-void quick_sort_hoare(int *array, size_t size);
-
 /**
- * swap_ints - Swap two integers in an array.
- * @a: The first integer to swap.
- * @b: The second integer to swap.
- */
-void swap_ints(int *a, int *b)
+*swap - the positions of two elements into an array
+*@array: array
+*@item1: array element
+*@item2: array element
+*/
+void swap(int *array, ssize_t item1, ssize_t item2)
 {
 	int tmp;
 
-	tmp = *a;
-	*a = *b;
-	*b = tmp;
+	tmp = array[item1];
+	array[item1] = array[item2];
+	array[item2] = tmp;
 }
-
 /**
- * hoare_partition - Order a subset of an array of integers
- *                   according to the hoare partition scheme.
- * @array: The array of integers.
- * @size: The size of the array.
- * @left: The starting index of the subset to order.
- * @right: The ending index of the subset to order.
- *
- * Return: The final partition index.
- *
- * Description: Uses the last element of the partition as the driver.
- * Prints the array after each swap of two elements.
+ *hoare_partition - hoare partition sorting scheme implementation
+ *@array: array
+ *@first: first array element
+ *@last: last array element
+ *@size: size array
+ *Return: return the position of the last element sorted
  */
-int hoare_partition(int *array, size_t size, int left, int right)
+int hoare_partition(int *array, int first, int last, int size)
 {
-	int driver, up, down;
+	int current = first - 1, finder = last + 1;
+	int pivot = array[last];
 
-	driver = array[right];
-	for (up = left - 1, down = right + 1; up < down;)
+	while (1)
 	{
+
 		do {
-			up++;
-		} while (array[up] < driver);
+			current++;
+		} while (array[current] < pivot);
 		do {
-			down--;
-		} while (array[down] > driver);
-
-		if (up < down)
-		{
-			swap_ints(array + up, array + down);
-			print_array(array, size);
-		}
+			finder--;
+		} while (array[finder] > pivot);
+		if (current >= finder)
+			return (current);
+		swap(array, current, finder);
+		print_array(array, size);
 	}
-
-	return (up);
 }
-
 /**
- * hoare_sort - Implement the quicksort algorithm through recursion.
- * @array: An array of integers to sort.
- * @size: The size of the array.
- * @left: The starting index of the array partition to order.
- * @right: The ending index of the array partition to order.
- *
- * Description: Uses the Hoare partition scheme.
+ *qs - qucksort algorithm implementation
+ *@array: array
+ *@first: first array element
+ *@last: last array element
+ *@size: array size
  */
-void hoare_sort(int *array, size_t size, int left, int right)
+void qs(int *array, ssize_t first, ssize_t last, int size)
 {
-	int belong;
+	ssize_t position = 0;
 
-	if (right - left > 0)
+	if (first < last)
 	{
-		belong = hoare_partition(array, size, left, right);
-		hoare_sort(array, size, left, belong - 1);
-		hoare_sort(array, size, belong, right);
+		position = hoare_partition(array, first, last, size);
+		qs(array, first, position - 1, size);
+		qs(array, position, last, size);
 	}
 }
-
 /**
- * quick_sort_hoare - Sort an array of integers in ascending
- *                    order using the quicksort algorithm.
- * @array: An array of integers.
- * @size: The size of the array.
- *
- * Description: Uses the Hoare partition scheme. Prints
- * the array after each swap of two elements.
+ *quick_sort_hoare - prepare the terrain to quicksort algorithm
+ *@array: array
+ *@size: array size
  */
 void quick_sort_hoare(int *array, size_t size)
 {
-	if (array == NULL || size < 2)
+	if (!array || size < 2)
 		return;
-
-	hoare_sort(array, size, 0, size - 1);
+	qs(array, 0, size - 1, size);
 }