The Slowest Sorting Algorithms

// C# program for the 
// stooge sort
using System;
class GFG{
    
// Function to implement 
// stooge sort
static void stoogesort(int []arr, 
                       int l, int h)
{
  // Base Case
  if (l >= h)
    return;

  // If first element is smaller
  // than last element, swap them
  if (arr[l] > arr[h]) 
  {
    int temp = arr[l];
    arr[l] = arr[h];
    arr[h] = temp;
  }

  // If there are more than 
  // 2 elements in the array
  if (h - l + 1 > 2) 
  {
    int t = (h - l + 1) / 3;

    // Recursively sort the 
    // first 2/3 elements
    stoogesort(arr, l, h - t);

    // Recursively sort the 
    // last 2/3 elements
    stoogesort(arr, l + t, h);

    // Recursively sort the 
    // first 2/3 elements again
    stoogesort(arr, l, h - t);
  }
}

// Driver Code
public static void Main(String[] args)
{
  int []arr = {2, 4, 5, 3, 1};
  int N = arr.Length;

  // Function Call
  stoogesort(arr, 0, N - 1);

  // Display the sorted array
  for (int i = 0; i < N; i++) 
  {
    Console.Write(arr[i] + " ");
  }
}
}

// This code is contributed by Princi Singh

// C# program to implement Slow sort
using System;
class GFG
{

// Function that implements Slow Sort
static void slowSort(int []A, int i, int j)
{
    // Base Case
    if (i >= j)
        return;

    // Middle value
    int m = (i + j) / 2;

    // Recursively call with left half
    slowSort(A, i, m);

    // Recursively call with right half
    slowSort(A, m + 1, j);

    // Swap if first element
    // is lower than second
    if (A[j] < A[m]) 
    {
        int temp = A[j];
        A[j] = A[m];
        A[m] = temp;
    }

    // Recursively call with whole
    // array except maximum element
    slowSort(A, i, j - 1);
}

// Function to print the array
static void printArray(int []arr, int size)
{
    int i;
    for (i = 0; i < size; i++)
        Console.Write(arr[i] + " ");
    Console.WriteLine();
}

// Driver Code
public static void Main(String[] args)
{
    int []arr = { 6, 8, 9, 4, 12, 1 };
    int N = arr.Length;

    // Function call
    slowSort(arr, 0, N - 1);

    // Display the sorted array
    printArray(arr, N);
}
}

// This code is contributed by 29AjayKumar 

using System;
using System.Collections.Generic;
using System.Threading;

class Program {
    // List for storing the sorted values
    static List<int> A = new List<int>();

    // Function for print the array
    static void PrintArray(List<int> arr, int size)
    {
        for (int i = 0; i < size; i++) {
            Console.Write(arr[i] + " ");
        }
    }

    // The instruction set for a thread
    static void Add(int x)
    {
        // Temporarily suspend execution
        // of each thread for x amount
        // of milliseconds
        Thread.Sleep(x);

        // Every thread will wake up after
        // a particular time and add the
        // value to the sorted list
        lock(A) { A.Add(x); }
    }

    // Function for Sleep sort
    static void SleepSort(int[] arr, int N)
    {
        List<Thread> threads = new List<Thread>();
        for (int i = 0; i < N; i++) {

            // New threads were launched by
            // using lambda expression as
            // the ThreadStart delegate
            threads.Add(new Thread(() = > Add(arr[i])));
            threads[i].Start();
        }

        // Waiting for each thread
        // to finish execution
        foreach(var thread in threads) { thread.Join(); }

        // Display the sorted array
        Console.Write("Array after sorting: ");
        PrintArray(A, A.Count);
    }

    // Driver Code
    static void Main()
    {
        int[] arr = { 8, 9, 1, 4, 3 };
        int N = arr.Length;

        // SleepSort function call
        SleepSort(arr, N);
    }
}

// Output: Array after sorting: 1 3 4 8 9

using System;

class Program {
    static void Main(string[] args)
    {
        int[] arr = { 8, 9, 1, 4, 3 };
        int N = arr.Length;

        // Function Call
        bogosort(arr, N);

        // Display the sorted array
        Console.Write("Array after sorting: ");
        for (int i = 0; i < N; ++i) {
            Console.Write(arr[i] + " ");
        }
        Console.WriteLine();
    }

    // Function to sort array using bogosort
    static void bogosort(int[] arr, int N)
    {
        // Run the loop until
        // array is not sorted
        while (!is_sorted(arr, N)) {
            // All possible permutations
            next_permutation(arr, N);
        }
    }

    static bool is_sorted(int[] arr, int N)
    {
        for (int i = 0; i < N - 1; ++i) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        }
        return true;
    }

    static void next_permutation(int[] arr, int N)
    {
        // Find non-increasing suffix
        int i = N - 1;
        while (i > 0 && arr[i - 1] >= arr[i]) {
            i--;
        }
        if (i <= 0) {
            // Array is sorted in descending order, so
            // reverse it
            Array.Reverse(arr, 0, N);
            return;
        }

        // Find successor to pivot
        int j = N - 1;
        while (arr[j] <= arr[i - 1]) {
            j--;
        }

        // Swap pivot with its successor
        int temp = arr[i - 1];
        arr[i - 1] = arr[j];
        arr[j] = temp;

        // Reverse the suffix
        j = N - 1;
        while (i < j) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
}

// C# program to implement Bogo Sort
// using random shuffle
using System;
class GfG 
{
  
  // Function to check if array is
  // sorted or not
  static bool isSorted(int[] a, int N)
  {
    while (--N > 1) {

      // Break condition for
      // unsorted array
      if (a[N] < a[N - 1])
        return false;
    }
    return true;
  }
  
  // Function to generate permutation
  // of the array
  static void shuffle(int[] a, int N)
  {
    Random rnd = new Random();
    for (int i = 0; i < N; i++) {
      int y = rnd.Next() + 1;
      y = y % N;
      
      // document.write(y);
      int temp = a[i];
      a[i] = a[y];
      a[y] = temp;
    }
  }
  // Function to sort array using
  // Bogo sort
  static void bogosort(int[] a, int N)
  {
    // If array is not sorted
    // then shuffle array again
    while (isSorted(a, N) == false) {

      shuffle(a, N);
    }
  }
  // Function to print the array
  static void printArray(int[] a, int N)
  {
    for (int i = 0; i < N; i++) {
      Console.Write(a[i] + " ");
    }
  }

  static void Main()
  {
    int[] a = { 3, 2, 5, 1, 0, 4 };
    int N = 6;

    // Function Call
    bogosort(a, N);
    Console.Write("Array after sorting:");
    printArray(a, N);
  }
}

// This code is contributed by garg28harsh.