initial commit.

Author: aishuarya

src/main/java/com/thealgorithms/sorts/SleepSort.java

@@ -0,0 +1,56 @@
+package com.thealgorithms.sorts;
+
+/**
+ *  @author Aiswarya PM (https://github.com/aishuarya)
+ * The SleepSort class demonstrates the Sleep Sort algorithm.
+ * Sleep Sort is a sorting algorithm that works by leveraging the concurrency of threads.
+ * For each number in the list, a thread is created that sleeps for a duration proportional
+ * to the value of the number. After waking up, the thread prints the number.
+ * Thus, numbers with smaller values wake up and are printed earlier than those with larger values.
+ *
+ * Note: The sleep duration is not always precise due to system scheduling and thread management.
+ * As a result, this algorithm may not always produce correct results for all inputs, especially
+ * with closely adjacent numbers. For such cases, using a BlockingQueue to store and retrieve
+ * numbers in the order they are processed can ensure correct output.
+ */
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class SleepSort {
+
+    public static void sleepSort(ArrayList<Integer> array) {
+        ArrayList<Thread> threads = new ArrayList<>();
+
+        for (int numbers : array) {
+            Thread thread = new Thread(() -> {
+                try {
+                    Thread.sleep(numbers);  // Sleep for 'num' milliseconds
+                    System.out.print(numbers + " ");  // Print the number after sleeping
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            });
+
+            threads.add(thread); // Add the thread to the ArrayList
+            thread.start(); // Start the thread
+        }
+
+        for (Thread thread : threads) {
+            try {
+                thread.join(); // Wait for each thread to finish
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        // Example usage
+        ArrayList<Integer> numbers = new ArrayList<>();
+        Collections.addAll(numbers, 15, 23, 8, 41, 30);
+
+        System.out.println("Sorting numbers using Sleep Sort:");
+        sleepSort(numbers);
+    }
+}

src/test/java/com/thealgorithms/sorts/SleepSortTest.java

@@ -0,0 +1,99 @@
+package com.thealgorithms.sorts;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class SleepSortTest {
+
+    // Method to capture the output of the SleepSort
+    private String captureOutput(Runnable task) {
+        // Create a stream to capture output
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        PrintStream originalOut = System.out;
+        System.setOut(new PrintStream(outputStream));
+
+        // Run the task
+        task.run();
+
+        // Restore original output
+        System.setOut(originalOut);
+
+        // Return the captured output
+        return outputStream.toString().trim();
+    }
+
+    @Test
+    public void testSleepSort() {
+        ArrayList<Integer> numbers = new ArrayList<>();
+        Collections.addAll(numbers, 4, 6, 8, 1, 10);
+
+        // Capture output
+        String output = captureOutput(() -> SleepSort.sleepSort(numbers));
+
+        // Expected output
+        String expected = "1 4 6 8 10";
+
+        // Check if the captured output matches the expected output
+        assertEquals(expected, output);
+    }
+
+    @Test
+    public void testSleepSortWithAdjacentNumbers() {
+        ArrayList<Integer> numbers = new ArrayList<>();
+        Collections.addAll(numbers, 1, 2, 3, 4);
+
+        // Capture output
+        String output = captureOutput(() -> SleepSort.sleepSort(numbers));
+
+        // Expected output
+        String expected = "1 2 3 4";
+
+        // Check if the output is sorted
+        List<Integer> outputNumbers = parseOutput(output);
+        assertTrue(isSorted(outputNumbers), "The output is not sorted.");
+
+        // Check if the output contains all expected numbers
+        assertEquals(expected, output, "The output does not contain the expected numbers.");
+    }
+
+    @Test
+    public void testSleepSortWithLargeNumbers() {
+        ArrayList<Integer> numbers = new ArrayList<>();
+        Collections.addAll(numbers, 1000, 500, 2000, 1500);
+
+        // Capture output
+        String output = captureOutput(() -> SleepSort.sleepSort(numbers));
+
+        // Expected output
+        String expected = "500 1000 1500 2000";
+
+        // Check if the captured output matches the expected output
+        assertEquals(expected, output);
+    }
+
+    // Helper method to parse the output string to a list of integers
+    private List<Integer> parseOutput(String output) {
+        String[] parts = output.split("\\s+");
+        List<Integer> numbers = new ArrayList<>();
+        for (String part : parts) {
+            numbers.add(Integer.parseInt(part));
+        }
+        return numbers;
+    }
+    private boolean isSorted(List<Integer> list) {
+        for (int i = 1; i < list.size(); i++) {
+            if (list.get(i - 1) > list.get(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}