Added Sorting and Search Algorithms to C (quicksnip-dev#199)

Author: utkarshkonwar

public/consolidated/c.json

@@ -41,5 +41,106 @@
                 "code": "#include<stdio.h>\nvoid swap(int* num1,int* num2){\n    *num1 = *num1 + *num2;\n    *num2 = *num1 - *num2;\n    *num1 = *num1 - *num2;\n}\n\n// Usage:\nint a = 3,b = 4;\nswap(&a,&b); // swaps the values of the a and b variables\n"
             }
         ]
+    },
+    {
+        "name": "Search",
+        "snippets": [
+            {
+                "title": "Binary Search ",
+                "description": "Searches for an element in a sorted array using the Binary Search algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "search",
+                    "binarysearch",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "int binarySearch(int arr[], int low, int high, int x) {\n  while (low <= high) {\n    int mid = low + (high - low) / 2;\n\n    // Check if x is present at mid\n    if (arr[mid] == x) {\n      return mid;\n    }\n\n    // If x is smaller, search the left half\n    if (arr[mid] > x) {\n      high = mid - 1;\n    } else { // If x is larger, search the right half\n      low = mid + 1;\n    }\n  }\n  return -1; // Element not found\n}\n\n// Usage:\nint arr[] = {2, 3, 4, 10, 40};\nint n = sizeof(arr) / sizeof(arr[0]);\nint x = 10;\nint result = binarySearch(arr, 0, n - 1, x);\n// result = 3 (index of the element 10)\n\n\n"
+            },
+            {
+                "title": "Linear Search ",
+                "description": "Searches for an element in an array using the Linear Search algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "search",
+                    "linearsearch",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "int linearSearch(int arr[], int n, int x) {\n  for (int i = 0; i < n; i++) {\n    if (arr[i] == x) {\n      return i; // Element found at index i\n    }\n  }\n  return -1; // Element not found\n}\n\n// Usage:\nint arr[] = {10, 20, 30, 40, 50};\nint n = sizeof(arr) / sizeof(arr[0]);\nint x = 30;\nint result = linearSearch(arr, n, x);\n// result = 2 (index of the element 30)\n\n"
+            }
+        ]
+    },
+    {
+        "name": "Sorting",
+        "snippets": [
+            {
+                "title": "Bubble Sort ",
+                "description": "Sorts an array of integers using the Bubble Sort algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "sorting",
+                    "bubblesort",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "void bubbleSort(int arr[], int n) {\n  for (int i = 0; i < n - 1; i++) {\n    for (int j = 0; j < n - i - 1; j++) {\n      if (arr[j] > arr[j + 1]) {\n        // Swap arr[j] and arr[j + 1]\n        int temp = arr[j];\n        arr[j] = arr[j + 1];\n        arr[j + 1] = temp;\n      }\n    }\n  }\n}\n\n// Usage:\nint arr[] = {64, 34, 25, 12, 22, 11, 90};\nint n = sizeof(arr) / sizeof(arr[0]);\nbubbleSort(arr, n);\n// Now arr[] is sorted: {11, 12, 22, 25, 34, 64, 90}\n"
+            },
+            {
+                "title": "Insertion Sort ",
+                "description": "Sorts an array of integers using the Insertion Sort algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "sorting",
+                    "insertionsort",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "void insertionSort(int arr[], int n) {\n  for (int i = 1; i < n; i++) {\n    int key = arr[i];\n    int j = i - 1;\n\n    // Move elements of arr[0..i-1] that are greater than key\n    // to one position ahead of their current position\n    while (j >= 0 && arr[j] > key) {\n      arr[j + 1] = arr[j];\n      j--;\n    }\n    arr[j + 1] = key;\n  }\n}\n\n// Usage:\nint arr[] = {12, 11, 13, 5, 6};\nint n = sizeof(arr) / sizeof(arr[0]);\ninsertionSort(arr, n);\n// Now arr[] is sorted: {5, 6, 11, 12, 13}\n\n"
+            },
+            {
+                "title": "Merge Sort ",
+                "description": "Sorts an array of integers using the Merge Sort algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "sorting",
+                    "mergesort",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "#include <stdio.h>\n\nvoid merge(int arr[], int l, int m, int r) {\n  int n1 = m - l + 1;\n  int n2 = r - m;\n\n  // Temporary arrays\n  int L[n1], R[n2];\n\n  // Copy data to temporary arrays L[] and R[]\n  for (int i = 0; i < n1; i++)\n    L[i] = arr[l + i];\n  for (int j = 0; j < n2; j++)\n    R[j] = arr[m + 1 + j];\n\n  int i = 0, j = 0, k = l;\n\n  // Merge the temporary arrays back into arr[l..r]\n  while (i < n1 && j < n2) {\n    if (L[i] <= R[j]) {\n      arr[k] = L[i];\n      i++;\n    } else {\n      arr[k] = R[j];\n      j++;\n    }\n    k++;\n  }\n\n  // Copy remaining elements of L[], if any\n  while (i < n1) {\n    arr[k] = L[i];\n    i++;\n    k++;\n  }\n\n  // Copy remaining elements of R[], if any\n  while (j < n2) {\n    arr[k] = R[j];\n    j++;\n    k++;\n  }\n}\n\nvoid mergeSort(int arr[], int l, int r) {\n  if (l < r) {\n    int m = l + (r - l) / 2;\n\n    // Sort first and second halves\n    mergeSort(arr, l, m);\n    mergeSort(arr, m + 1, r);\n\n    merge(arr, l, m, r);\n  }\n}\n\n// Usage:\nint arr[] = {38, 27, 43, 3, 9, 82, 10};\nint n = sizeof(arr) / sizeof(arr[0]);\nmergeSort(arr, 0, n - 1);\n// Now arr[] is sorted: {3, 9, 10, 27, 38, 43, 82}\n\n"
+            },
+            {
+                "title": "Quick Sort ",
+                "description": "Sorts an array of integers using the Quick Sort algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "sorting",
+                    "quicksort",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "int partition(int arr[], int low, int high) {\n  int pivot = arr[high]; // Pivot element\n  int i = low - 1;\n\n  for (int j = low; j < high; j++) {\n    if (arr[j] < pivot) {\n      i++;\n      // Swap arr[i] and arr[j]\n      int temp = arr[i];\n      arr[i] = arr[j];\n      arr[j] = temp;\n    }\n  }\n\n  // Swap arr[i + 1] and arr[high] (pivot)\n  int temp = arr[i + 1];\n  arr[i + 1] = arr[high];\n  arr[high] = temp;\n\n  return i + 1;\n}\n\nvoid quickSort(int arr[], int low, int high) {\n  if (low < high) {\n    int pi = partition(arr, low, high);\n\n    // Recursively sort elements before and after partition\n    quickSort(arr, low, pi - 1);\n    quickSort(arr, pi + 1, high);\n  }\n}\n\n// Usage:\nint arr[] = {10, 7, 8, 9, 1, 5};\nint n = sizeof(arr) / sizeof(arr[0]);\nquickSort(arr, 0, n - 1);\n// Now arr[] is sorted: {1, 5, 7, 8, 9, 10}\n\n"
+            },
+            {
+                "title": "Selection Sort ",
+                "description": "Sorts an array of integers using the Selection Sort algorithm.",
+                "author": "0xHouss",
+                "tags": [
+                    "sorting",
+                    "selectionsort",
+                    "array",
+                    "algorithm"
+                ],
+                "contributors": [],
+                "code": "void selectionSort(int arr[], int n) {\n  for (int i = 0; i < n - 1; i++) {\n    int minIdx = i;\n\n    // Find the minimum element in the unsorted part of the array\n    for (int j = i + 1; j < n; j++) {\n      if (arr[j] < arr[minIdx]) {\n        minIdx = j;\n      }\n    }\n\n    // Swap the found minimum element with the first element of the unsorted part\n    int temp = arr[minIdx];\n    arr[minIdx] = arr[i];\n    arr[i] = temp;\n  }\n}\n\n// Usage:\nint arr[] = {64, 25, 12, 22, 11};\nint n = sizeof(arr) / sizeof(arr[0]);\nselectionSort(arr, n);\n// Now arr[] is sorted: {11, 12, 22, 25, 64}\n\n"
+            }
+        ]
     }
 ]

snippets/c/search/binary-search.md

@@ -0,0 +1,36 @@
+---
+title: Binary Search 
+description: Searches for an element in a sorted array using the Binary Search algorithm.
+author: 0xHouss
+tags: search,binarysearch,array,algorithm
+---
+
+```c
+int binarySearch(int arr[], int low, int high, int x) {
+  while (low <= high) {
+    int mid = low + (high - low) / 2;
+
+    // Check if x is present at mid
+    if (arr[mid] == x) {
+      return mid;
+    }
+
+    // If x is smaller, search the left half
+    if (arr[mid] > x) {
+      high = mid - 1;
+    } else { // If x is larger, search the right half
+      low = mid + 1;
+    }
+  }
+  return -1; // Element not found
+}
+
+// Usage:
+int arr[] = {2, 3, 4, 10, 40};
+int n = sizeof(arr) / sizeof(arr[0]);
+int x = 10;
+int result = binarySearch(arr, 0, n - 1, x);
+// result = 3 (index of the element 10)
+
+
+```

snippets/c/search/linear-search.md

@@ -0,0 +1,25 @@
+---
+title: Linear Search 
+description: Searches for an element in an array using the Linear Search algorithm.
+author: 0xHouss
+tags: search,linearsearch,array,algorithm
+---
+
+```c
+int linearSearch(int arr[], int n, int x) {
+  for (int i = 0; i < n; i++) {
+    if (arr[i] == x) {
+      return i; // Element found at index i
+    }
+  }
+  return -1; // Element not found
+}
+
+// Usage:
+int arr[] = {10, 20, 30, 40, 50};
+int n = sizeof(arr) / sizeof(arr[0]);
+int x = 30;
+int result = linearSearch(arr, n, x);
+// result = 2 (index of the element 30)
+
+```

snippets/c/sorting/bubble-sort.md

@@ -0,0 +1,27 @@
+---
+title: Bubble Sort 
+description: Sorts an array of integers using the Bubble Sort algorithm.
+author: 0xHouss
+tags: sorting,bubblesort,array,algorithm
+---
+
+```c
+void bubbleSort(int arr[], int n) {
+  for (int i = 0; i < n - 1; i++) {
+    for (int j = 0; j < n - i - 1; j++) {
+      if (arr[j] > arr[j + 1]) {
+        // Swap arr[j] and arr[j + 1]
+        int temp = arr[j];
+        arr[j] = arr[j + 1];
+        arr[j + 1] = temp;
+      }
+    }
+  }
+}
+
+// Usage:
+int arr[] = {64, 34, 25, 12, 22, 11, 90};
+int n = sizeof(arr) / sizeof(arr[0]);
+bubbleSort(arr, n);
+// Now arr[] is sorted: {11, 12, 22, 25, 34, 64, 90}
+```

snippets/c/sorting/insertion-sort.md

@@ -0,0 +1,30 @@
+---
+title: Insertion Sort 
+description: Sorts an array of integers using the Insertion Sort algorithm.
+author: 0xHouss
+tags: sorting,insertionsort,array,algorithm
+---
+
+```c
+void insertionSort(int arr[], int n) {
+  for (int i = 1; i < n; i++) {
+    int key = arr[i];
+    int j = i - 1;
+
+    // Move elements of arr[0..i-1] that are greater than key
+    // to one position ahead of their current position
+    while (j >= 0 && arr[j] > key) {
+      arr[j + 1] = arr[j];
+      j--;
+    }
+    arr[j + 1] = key;
+  }
+}
+
+// Usage:
+int arr[] = {12, 11, 13, 5, 6};
+int n = sizeof(arr) / sizeof(arr[0]);
+insertionSort(arr, n);
+// Now arr[] is sorted: {5, 6, 11, 12, 13}
+
+```

snippets/c/sorting/merge-sort.md

@@ -0,0 +1,71 @@
+---
+title: Merge Sort 
+description: Sorts an array of integers using the Merge Sort algorithm.
+author: 0xHouss
+tags: sorting,mergesort,array,algorithm
+---
+
+```c
+#include <stdio.h>
+
+void merge(int arr[], int l, int m, int r) {
+  int n1 = m - l + 1;
+  int n2 = r - m;
+
+  // Temporary arrays
+  int L[n1], R[n2];
+
+  // Copy data to temporary arrays L[] and R[]
+  for (int i = 0; i < n1; i++)
+    L[i] = arr[l + i];
+  for (int j = 0; j < n2; j++)
+    R[j] = arr[m + 1 + j];
+
+  int i = 0, j = 0, k = l;
+
+  // Merge the temporary arrays back into arr[l..r]
+  while (i < n1 && j < n2) {
+    if (L[i] <= R[j]) {
+      arr[k] = L[i];
+      i++;
+    } else {
+      arr[k] = R[j];
+      j++;
+    }
+    k++;
+  }
+
+  // Copy remaining elements of L[], if any
+  while (i < n1) {
+    arr[k] = L[i];
+    i++;
+    k++;
+  }
+
+  // Copy remaining elements of R[], if any
+  while (j < n2) {
+    arr[k] = R[j];
+    j++;
+    k++;
+  }
+}
+
+void mergeSort(int arr[], int l, int r) {
+  if (l < r) {
+    int m = l + (r - l) / 2;
+
+    // Sort first and second halves
+    mergeSort(arr, l, m);
+    mergeSort(arr, m + 1, r);
+
+    merge(arr, l, m, r);
+  }
+}
+
+// Usage:
+int arr[] = {38, 27, 43, 3, 9, 82, 10};
+int n = sizeof(arr) / sizeof(arr[0]);
+mergeSort(arr, 0, n - 1);
+// Now arr[] is sorted: {3, 9, 10, 27, 38, 43, 82}
+
+```

snippets/c/sorting/quick-sort.md

@@ -0,0 +1,47 @@
+---
+title: Quick Sort 
+description: Sorts an array of integers using the Quick Sort algorithm.
+author: 0xHouss
+tags: sorting,quicksort,array,algorithm
+---
+
+```c
+int partition(int arr[], int low, int high) {
+  int pivot = arr[high]; // Pivot element
+  int i = low - 1;
+
+  for (int j = low; j < high; j++) {
+    if (arr[j] < pivot) {
+      i++;
+      // Swap arr[i] and arr[j]
+      int temp = arr[i];
+      arr[i] = arr[j];
+      arr[j] = temp;
+    }
+  }
+
+  // Swap arr[i + 1] and arr[high] (pivot)
+  int temp = arr[i + 1];
+  arr[i + 1] = arr[high];
+  arr[high] = temp;
+
+  return i + 1;
+}
+
+void quickSort(int arr[], int low, int high) {
+  if (low < high) {
+    int pi = partition(arr, low, high);
+
+    // Recursively sort elements before and after partition
+    quickSort(arr, low, pi - 1);
+    quickSort(arr, pi + 1, high);
+  }
+}
+
+// Usage:
+int arr[] = {10, 7, 8, 9, 1, 5};
+int n = sizeof(arr) / sizeof(arr[0]);
+quickSort(arr, 0, n - 1);
+// Now arr[] is sorted: {1, 5, 7, 8, 9, 10}
+
+```

snippets/c/sorting/selection-sort.md

@@ -0,0 +1,33 @@
+---
+title: Selection Sort 
+description: Sorts an array of integers using the Selection Sort algorithm.
+author: 0xHouss
+tags: sorting,selectionsort,array,algorithm
+---
+
+```c
+void selectionSort(int arr[], int n) {
+  for (int i = 0; i < n - 1; i++) {
+    int minIdx = i;
+
+    // Find the minimum element in the unsorted part of the array
+    for (int j = i + 1; j < n; j++) {
+      if (arr[j] < arr[minIdx]) {
+        minIdx = j;
+      }
+    }
+
+    // Swap the found minimum element with the first element of the unsorted part
+    int temp = arr[minIdx];
+    arr[minIdx] = arr[i];
+    arr[i] = temp;
+  }
+}
+
+// Usage:
+int arr[] = {64, 25, 12, 22, 11};
+int n = sizeof(arr) / sizeof(arr[0]);
+selectionSort(arr, n);
+// Now arr[] is sorted: {11, 12, 22, 25, 64}
+
+```