diff --git a/src/main/java/com/thealgorithms/backtracking/Combination.java b/src/main/java/com/thealgorithms/backtracking/Combination.java
index ecaf7428f986..31eeb09d667c 100644
--- a/src/main/java/com/thealgorithms/backtracking/Combination.java
+++ b/src/main/java/com/thealgorithms/backtracking/Combination.java
@@ -7,19 +7,22 @@
 import java.util.TreeSet;
 
 /**
- * Finds all permutations of given array
- * @author Alan Piao (<a href="https://github.com/cpiao3">git-Alan Piao</a>)
+ * Finds all combinations of a given array using backtracking
+ * 
+ * @author Alan Piao
+   @edit Sarthak Shelar
  */
 public final class Combination {
     private Combination() {
     }
 
     /**
-     * Find all combinations of given array using backtracking
+     * Find all combinations of a given array using backtracking
+     * 
      * @param arr the array.
-     * @param n length of combination
+     * @param n   length of combination
      * @param <T> the type of elements in the array.
-     * @return a list of all combinations of length n. If n == 0, return null.
+     * @return a list of all combinations of length n. If n == 0, return an empty list.
      */
     public static <T> List<TreeSet<T>> combination(T[] arr, int n) {
         if (n < 0) {
@@ -29,39 +32,35 @@ public static <T> List<TreeSet<T>> combination(T[] arr, int n) {
         if (n == 0) {
             return Collections.emptyList();
         }
+
         T[] array = arr.clone();
-        Arrays.sort(array);
+        Arrays.sort(array); // Sort to maintain consistent order
 
         List<TreeSet<T>> result = new LinkedList<>();
-        backtracking(array, n, 0, new TreeSet<T>(), result);
+        backtrack(array, n, 0, new LinkedList<>(), result);
         return result;
     }
 
     /**
      * Backtrack all possible combinations of a given array
-     * @param arr the array.
-     * @param n length of the combination
-     * @param index the starting index.
-     * @param currSet set that tracks current combination
-     * @param result the list contains all combination.
-     * @param <T> the type of elements in the array.
+     * 
+     * @param arr     the array.
+     * @param n       length of the combination
+     * @param index   the starting index.
+     * @param current current combination under construction
+     * @param result  the list that contains all valid combinations
+     * @param <T>     the type of elements in the array.
      */
-    private static <T> void backtracking(T[] arr, int n, int index, TreeSet<T> currSet, List<TreeSet<T>> result) {
-        if (index + n - currSet.size() > arr.length) {
-            return;
-        }
-        if (currSet.size() == n - 1) {
-            for (int i = index; i < arr.length; i++) {
-                currSet.add(arr[i]);
-                result.add(new TreeSet<>(currSet));
-                currSet.remove(arr[i]);
-            }
+    private static <T> void backtrack(T[] arr, int n, int index, LinkedList<T> current, List<TreeSet<T>> result) {
+        if (current.size() == n) {
+            result.add(new TreeSet<>(current)); // Convert to TreeSet to ensure uniqueness and sorted order
             return;
         }
+
         for (int i = index; i < arr.length; i++) {
-            currSet.add(arr[i]);
-            backtracking(arr, n, i + 1, currSet, result);
-            currSet.remove(arr[i]);
+            current.add(arr[i]);
+            backtrack(arr, n, i + 1, current, result);
+            current.removeLast();
         }
     }
 }