Refactor code style to the latest Swift version and fix time & space complexity analysis

Author: Yi Gu

Diff for: DFS/Combinations.swift

@@ -2,30 +2,27 @@
  * Question Link: https://leetcode.com/problems/combinations/
  * Primary idea: Classic Depth-first Search, another version of Subsets
  * 
- * Time Complexity: O(n^n), Space Complexity: O(n)
+ * Time Complexity: O(n * 2^n), Space Complexity: O(n * 2^n)
  *
  */
 
 class Combinations {
-    func combine(n: Int, _ k: Int) -> [[Int]] {
-        var res = [[Int]]()
-        var path = [Int]()
-        let nums = [Int](1...n)
+    func combine(_ n: Int, _ k: Int) -> [[Int]] {
+        var res = [[Int]](), path = [Int]()
 
-        _dfs(nums, &res, &path, 0, k)
+        dfs(&res, &path, 0, Array(1...n), k)
 
         return res
     }
 
-    private func _dfs(nums: [Int], inout _ res: [[Int]], inout _ path: [Int], _ index: Int, _ k: Int) {
+    private func dfs(_ res: inout [[Int]], _ path: inout [Int], _ idx: Int, _ nums: [Int],  _ k: Int) {
         if path.count == k {
-            res.append([Int](path))
-            return
+            res.append(path)
         }
 
-        for i in index..<nums.count {
+        for i in idx..<nums.count {
             path.append(nums[i])
-            _dfs(nums, &res, &path, i + 1, k)
+            dfs(&res, &path, i + 1, nums, k)
             path.removeLast()
         }
     }

Diff for: DFS/Subsets.swift

@@ -2,30 +2,25 @@
  * Question Link: https://leetcode.com/problems/subsets/
  * Primary idea: Classic Depth-first Search
  * 
- * Time Complexity: O(n^n), Space Complexity: O(n)
+ * Time Complexity: O(n * 2^n), Space Complexity: O(n * 2^n)
  *
  */
 
 class Subsets {
-    func subsets(nums: [Int]) -> [[Int]] {
-        var res = [[Int]]()
-        var path = [Int]()
+    func subsets(_ nums: [Int]) -> [[Int]] {
+        var res = [[Int]](), path = [Int]()
 
-        let nums = nums.sorted(by: <)
-        
-        _dfs(&res, &path, nums, 0)
+        dfs(&res, &path, 0, nums)
 
         return res
     }
 
-    private func _dfs(inout res: [[Int]], inout _ path: [Int], _ nums: [Int], _ index: Int) {
-        // termination case
-
+    private func dfs(_ res: inout [[Int]], _ path: inout [Int], _ idx: Int, _ nums: [Int]) {
         res.append(path)
 
-        for i in index..<nums.count {
+        for i in idx..<nums.count {
             path.append(nums[i])
-            _dfs(&res, &path, nums, i + 1)
+            dfs(&res, &path, i + 1, nums)
             path.removeLast()
         }
     }

Diff for: DFS/SubsetsII.swift

@@ -2,31 +2,29 @@
  * Question Link: https://leetcode.com/problems/subsets-ii/
  * Primary idea: Classic Depth-first Search, avoid duplicates by adopting the first occurrence
  * 
- * Time Complexity: O(n^n), Space Complexity: O(n)
+ * Time Complexity: O(n * 2^n), Space Complexity: O(n * 2^n)
  *
  */
 
 class SubsetsII {
-    func subsetsWithDup(nums: [Int]) -> [[Int]] {
+    func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
         var res = [[Int]](), path = [Int]()
 
-        let nums = nums.sorted(by: <)
-        
-        _dfs(&res, &path, nums, 0)
+        dfs(&res, &path, 0, nums.sorted())
 
         return res
     }
 
-    private func _dfs(inout res: [[Int]], inout _ path:[Int], _ nums: [Int], _ index: Int) {
+    private func dfs(_ res: inout [[Int]], _ path: inout [Int], _ idx: Int, _ nums: [Int]) {
         res.append(path)
 
-        for i in index..<nums.count {
-            if i > 0 && nums[i] == nums[i - 1] && i != index {
-                continue
+        for i in idx..<nums.count {
+            if i > 0 && nums[i] == nums[i - 1] && i != idx {
+                continue   
             }
 
             path.append(nums[i])
-            _dfs(&res, &path, nums, i + 1)
+            dfs(&res, &path, i + 1, nums)
             path.removeLast()
         }
     }