Add mandatory files solution

Author: hackerSa3edy

0-O

@@ -0,0 +1,3 @@
+O(n)
+O(n^2)
+O(n^2)

0-bubble_sort.c

@@ -0,0 +1,36 @@
+#include "sort.h"
+
+/**
+ * bubble_sort - Sorts an array of integers in ascending order using,
+ * the Bubble sort algorithm.
+ *
+ * @array: The array to be sorted.
+ * @size: Size of the array.
+*/
+void bubble_sort(int *array, size_t size)
+{
+	size_t upperFor, innerFor, sorted;
+	int holder;
+
+	if (size < 2)
+		return;
+
+	for (upperFor = 0; upperFor < size - 1; upperFor++)
+	{
+		sorted = 1;
+		for (innerFor = 0; innerFor < size - upperFor - 1; innerFor++)
+		{
+			if (array[innerFor] > array[innerFor + 1])
+			{
+				sorted = 0;
+				holder = array[innerFor];
+				array[innerFor] = array[innerFor + 1];
+				array[innerFor + 1] = holder;
+				print_array(array, size);
+			}
+
+		}
+		if (sorted == 1)
+			break;
+	}
+}

0-main.c

@@ -0,0 +1,19 @@
+#include "sort.h"
+
+/**
+ * main - Entry point
+ *
+ * Return: Always 0
+ */
+int main(void)
+{
+    int array[] = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
+    size_t n = sizeof(array) / sizeof(array[0]);
+
+    print_array(array, n);
+    printf("\n");
+    bubble_sort(array, n);
+    printf("\n");
+    print_array(array, n);
+    return (0);
+}

1-O

@@ -0,0 +1,3 @@
+O(n)
+O(n^2)
+O(n^2)

1-insertion_sort_list.c

@@ -0,0 +1,69 @@
+#include "sort.h"
+
+void swapNodes(listint_t **Fnode, listint_t **Snode);
+
+/**
+ * insertion_sort_list - Sorts a doubly linked list of integers in
+ * ascending order using the insertion sort algorithm.
+ *
+ * @list: The doubly linked list.
+*/
+void insertion_sort_list(listint_t **list)
+{
+	listint_t *holder = *list;
+
+	if ((*list)->next == NULL)
+		return;
+
+	while (holder->next != NULL)
+	{
+		if ((*list)->n > (*list)->next->n)
+		{
+			(*list)->prev = (*list)->next;
+			holder = (*list)->next;
+			if (holder->next != NULL)
+				holder->next->prev = *list;
+			(*list)->next = holder->next;
+			holder->prev = NULL;
+			holder->next = *list;
+			*list = holder;
+			print_list(*list);
+		}
+
+		holder = (*list)->next;
+		while (holder->next != NULL)
+		{
+			if (holder->n > holder->next->n)
+			{
+				/* swap */
+				swapNodes(&holder, &holder->next);
+				print_list(*list);
+				holder = *list;
+				break;
+			}
+			holder = holder->next;
+		}
+	}
+}
+
+/**
+ * swapNodes - Swap two lintint_t type Nodes.
+ *
+ * @F_node: First node.
+ * @S_node: Second node.
+*/
+void swapNodes(listint_t **F_node, listint_t **S_node)
+{
+	/* Swap two nodes */
+	listint_t *Fnode = *F_node, *Snode = *S_node;
+
+	(Fnode->prev)->next = Snode;
+	if (Snode->next != NULL)
+		(Snode->next)->prev = Fnode;
+
+	Fnode->next = Snode->next;
+	Snode->prev = Fnode->prev;
+
+	Snode->next = Fnode;
+	Fnode->prev = Snode;
+}

1-main.c

@@ -0,0 +1,54 @@
+#include "sort.h"
+
+/**
+ * create_listint - Creates a doubly linked list from an array of integers
+ *
+ * @array: Array to convert to a doubly linked list
+ * @size: Size of the array
+ *
+ * Return: Pointer to the first element of the created list. NULL on failure
+ */
+listint_t *create_listint(const int *array, size_t size)
+{
+    listint_t *list;
+    listint_t *node;
+    int *tmp;
+
+    list = NULL;
+    while (size--)
+    {
+        node = malloc(sizeof(*node));
+        if (!node)
+            return (NULL);
+        tmp = (int *)&node->n;
+        *tmp = array[size];
+        node->next = list;
+        node->prev = NULL;
+        list = node;
+        if (list->next)
+            list->next->prev = list;
+    }
+    return (list);
+}
+
+/**
+ * main - Entry point
+ *
+ * Return: Always 0
+ */
+int main(void)
+{
+    listint_t *list;
+    int array[] = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
+    size_t n = sizeof(array) / sizeof(array[0]);
+
+    list = create_listint(array, n);
+    if (!list)
+        return (1);
+    print_list(list);
+    printf("\n");
+    insertion_sort_list(&list);
+    printf("\n");
+    print_list(list);
+    return (0);
+}

2-O

@@ -0,0 +1,3 @@
+O(n^2)
+O(n^2)
+O(n^2)

2-main.c

@@ -0,0 +1,19 @@
+#include "sort.h"
+
+/**
+ * main - Entry point
+ *
+ * Return: Always 0
+ */
+int main(void)
+{
+    int array[] = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
+    size_t n = sizeof(array) / sizeof(array[0]);
+
+    print_array(array, n);
+    printf("\n");
+    selection_sort(array, n);
+    printf("\n");
+    print_array(array, n);
+    return (0);
+}

2-selection_sort.c

@@ -0,0 +1,37 @@
+#include "sort.h"
+
+/**
+ * selection_sort - Sorts an array of integers in ascending order,
+ * using Selection sort algorithm.
+ *
+ * @array: The array to be sorted.
+ * @size: Size of the array.
+*/
+void selection_sort(int *array, size_t size)
+{
+	size_t upperFor, innerFor, lowerInt_index;
+	int lowerInt;
+
+	if (size < 2)
+		return;
+
+	for (upperFor = 0; upperFor < size - 2; upperFor++)
+	{
+		lowerInt = array[upperFor];
+		lowerInt_index = upperFor;
+		for (innerFor = upperFor + 1; innerFor < size; innerFor++)
+		{
+			if (lowerInt > array[innerFor])
+			{
+				lowerInt = array[innerFor];
+				lowerInt_index = innerFor;
+			}
+		}
+		if (array[upperFor] != lowerInt)
+		{
+			array[lowerInt_index] = array[upperFor];
+			array[upperFor] = lowerInt;
+			print_array(array, size);
+		}
+	}
+}

3-O

@@ -0,0 +1,3 @@
+O(nlog(n))
+O(nlog(n))
+O(n^2)

3-main.c

@@ -0,0 +1,19 @@
+#include "sort.h"
+
+/**
+ * main - Entry point
+ *
+ * Return: Always 0
+ */
+int main(void)
+{
+    int array[] = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
+    size_t n = sizeof(array) / sizeof(array[0]);
+
+    print_array(array, n);
+    printf("\n");
+    quick_sort(array, n);
+    printf("\n");
+    print_array(array, n);
+    return (0);
+}

3-quick_sort.c

@@ -0,0 +1,79 @@
+#include "sort.h"
+
+int lomutoPartition(int *array, int low, int high, size_t size);
+void lomutoSort(int *array, int start, int end, size_t size);
+
+/**
+ * quick_sort - Sorts an array of integers in ascending order,
+ * using the Quick sort algorithm.
+ *
+ * @array: The array to be arranged.
+ * @size: Size of the array.
+*/
+void quick_sort(int *array, size_t size)
+{
+	if (size < 2)
+		return;
+	lomutoSort(array, 0, size - 1, size);
+}
+
+/**
+ * lomutoPartition - array partition
+ *
+ * @array: array to sort
+ * @low: first position
+ * @high: last position
+ * @size: array size
+ *
+ * Return: int pivot index
+ */
+int lomutoPartition(int *array, int low, int high, size_t size)
+{
+	int pivot, index, forIndex, temp;
+
+	pivot = array[high];
+	index = low - 1;
+	for (forIndex = low; forIndex < high; forIndex++)
+	{
+		if (pivot >= array[forIndex])
+		{
+			index += 1;
+			if (index < forIndex)
+			{
+				temp = array[index];
+				array[index] = array[forIndex];
+				array[forIndex] = temp;
+				print_array(array, size);
+			}
+		}
+	}
+
+	if (array[index + 1] > pivot)
+	{
+		temp = array[index + 1];
+		array[index + 1] = array[high];
+		array[high] = temp;
+		print_array(array, size);
+	}
+	return (index + 1);
+}
+
+/**
+ * lomutoSort - sorts an array of integers recursively
+ *
+ * @array: array to sort
+ * @start: first position
+ * @end: last position
+ * @size: array size
+ */
+void lomutoSort(int *array, int start, int end, size_t size)
+{
+	int partition_index;
+
+	if (start < end)
+	{
+		partition_index = lomutoPartition(array, start, end, size);
+		lomutoSort(array, start, partition_index - 1, size);
+		lomutoSort(array, partition_index + 1, end, size);
+	}
+}