Sleep Sort

Added Sleep Sort Algorithm

Author: iMeet07

Sorts/WiggleSort.js

@@ -0,0 +1,44 @@
+/**
+ * Sleep Sort is a sorting algorithm that sorts an array of non-negative integers.
+ * It works by "sleeping" for a duration proportional to each element's value.
+ * Elements with smaller values will "wake up" earlier and appear earlier in the sorted result.
+ *
+ * @param {number[]} arr - The array of non-negative integers to be sorted.
+ * @returns {Promise<number[]>} - A Promise that resolves to the sorted array.
+ *
+ * @example
+ * const input = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
+ * sleepSort(input).then((result) => {
+ *   console.log(result); // Output: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
+ * });
+ *
+ * Time Complexity: O(k * n)
+ * - k is the maximum value in the input array.
+ * - Sleeping for each element takes O(k) time, and there are n elements in the array.
+ * - Therefore, the time complexity is O(k * n).
+ *
+ * Space Complexity: O(n)
+ * - Additional space is required for the result array, which has n elements.
+ * - The space complexity is O(n).
+ */
+export function sleepSort(arr) {
+    // Helper function to sleep for a given duration (in milliseconds)
+    function sleep(duration) {
+      return new Promise((resolve) => setTimeout(resolve, duration));
+    }
+  
+    // Function to perform the sleep sort
+    async function performSleepSort() {
+      const result = [];
+      for (const num of arr) {
+        // Sleep for a duration proportional to the element's value
+        await sleep(num);
+        result.push(num);
+      }
+      return result;
+    }
+  
+    return performSleepSort();
+  }
+
+  

Sorts/test/SleepSort.js

@@ -0,0 +1,22 @@
+/**
+   * Jest tests for the sleepSort function.
+   */
+import { alternativeBubbleSort, sleepSort } from '../SleepSort'
+describe("sleepSort", () => {
+    it("should return an empty array when given an empty array", async () => {
+      const result = await sleepSort([]);
+      expect(result).toEqual([]);
+    });
+  
+    it("should sort the input array using sleep sort", async () => {
+      const input = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
+      const result = await sleepSort(input);
+      expect(result).toEqual([1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]);
+    });
+  
+    it("should handle duplicate values correctly", async () => {
+      const input = [3, 3, 3, 2, 2, 1];
+      const result = await sleepSort(input);
+      expect(result).toEqual([1, 2, 2, 3, 3, 3]);
+    });
+  });