Added two algorithms

Author: VeeruYadav45

Data-Structures/Array/LeadersInArray.js.test

@@ -0,0 +1,23 @@
+import { leaders } from '../leadersinarray.js';
+
+describe('leaders()', () => {
+    test('should return correct leaders for given array', () => {
+        expect(leaders([16, 17, 4, 3, 5, 2])).toEqual([17, 5, 2]);
+    });
+
+    test('should handle a single element array', () => {
+        expect(leaders([10])).toEqual([10]);
+    });
+
+    test('should handle already decreasing array', () => {
+        expect(leaders([10, 9, 8, 7])).toEqual([10, 9, 8, 7]);
+    });
+
+    test('should handle increasing array', () => {
+        expect(leaders([1, 2, 3, 4])).toEqual([4]);
+    });
+
+    test('should handle array with duplicates', () => {
+        expect(leaders([5, 5, 5, 5])).toEqual([5, 5, 5, 5]);
+    });
+});

Data-Structures/Array/leadersinarray.js

@@ -1,48 +1,16 @@
-/**
- * [Leaders in an Array](https://www.geeksforgeeks.org/leaders-in-an-array/)
- *
- * A leader in an array is an element that is greater than or equal to
- * all the elements to its right.
- *
- * Example:
- *   Input:  [16, 17, 4, 3, 5, 2]
- *   Output: [17, 5, 2]
- *
- * Algorithm:
- * - Start from the rightmost element (which is always a leader).
- * - Traverse the array from right to left, keeping track of the maximum so far.
- * - If the current element is greater than or equal to that maximum, it is a leader.
- * - Reverse the list of leaders at the end to preserve original order.
- *
- * @complexity O(n) — each element is visited once.
- * @flow
- */
-
-function leaders(arr) {
+export function leaders(arr) {
     const result = [];
     const n = arr.length;
-
-    // Start with the rightmost element
     let maxRight = arr[n - 1];
-
-    // Rightmost element is always a leader
     result.push(maxRight);
 
-    // Traverse the array from right to left
     for (let i = n - 2; i >= 0; i--) {
         if (arr[i] >= maxRight) {
             maxRight = arr[i];
             result.push(maxRight);
         }
     }
 
-    // Reverse the result array to maintain original order
     result.reverse();
-
     return result;
 }
-
-// Driver code
-const arr = [16, 17, 4, 3, 5, 2];
-const result = leaders(arr);
-console.log(result.join(' '));

Data-Structures/Array/test/CheckArraySortedOrNot.js.test

@@ -0,0 +1,23 @@
+import { isSorted } from '../checkarraysortedornot.js';
+
+describe('isSorted()', () => {
+    test('should return true for sorted array', () => {
+        expect(isSorted([10, 20, 30, 40, 50])).toBe(true);
+    });
+
+    test('should return false for unsorted array', () => {
+        expect(isSorted([10, 50, 30, 20])).toBe(false);
+    });
+
+    test('should return true for array with equal elements', () => {
+        expect(isSorted([5, 5, 5, 5])).toBe(true);
+    });
+
+    test('should return true for single element array', () => {
+        expect(isSorted([100])).toBe(true);
+    });
+
+    test('should return true for empty array', () => {
+        expect(isSorted([])).toBe(true);
+    });
+});

Data-Structures/Array/test/checkarraysortedornot.js

@@ -1,43 +1,10 @@
-/**
- * [Check if Array is Sorted](https://www.geeksforgeeks.org/check-if-an-array-is-sorted-in-ascending-order/)
- *
- * This function checks whether a given array is sorted in non-decreasing (ascending) order.
- *
- * Algorithm:
- * - Traverse the array from the second element onward.
- * - Compare each element with its previous one.
- * - If any element is smaller than its predecessor, the array is not sorted.
- * - Otherwise, if no such pair exists, the array is sorted.
- *
- * Example:
- *   Input:  [10, 20, 30, 40, 50]
- *   Output: true
- *
- * @param {number[]} arr - The input array of numbers.
- * @returns {boolean} true if the array is sorted in ascending order, false otherwise.
- * @complexity O(n) — each element is checked once.
- * @flow
- */
-
-function isSorted(arr) {
+export function isSorted(arr) {
     const n = arr.length;
 
-    // Iterate over the array and check if
-    // every element is greater than or equal to previous element.
     for (let i = 1; i < n; i++) {
         if (arr[i - 1] > arr[i]) {
             return false;
         }
     }
-
     return true;
 }
-
-// Driver Code
-const arr = [10, 20, 30, 40, 50];
-
-if (isSorted(arr)) {
-    console.log('true');
-} else {
-    console.log('false');
-}