Skip to content

Commit 0a2d881

Browse files
Srihari2222Srihari2222
authored
Sri Hari: Batch-6/Neetcode-150/Added-SwiftCode (#3936)
* Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode * Batch-6/Neetcode-150/Added-swiftcode
1 parent 822c53a commit 0a2d881

File tree

150 files changed

+17199
-148
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

150 files changed

+17199
-148
lines changed

‎articles/add-two-numbers.md

+73-1
Original file line numberDiff line numberDiff line change
@@ -303,6 +303,40 @@ class Solution {
303303
}
304304
```
305305

306+
```swift
307+
/**
308+
* Definition for singly-linked list.
309+
* public class ListNode {
310+
* public var val: Int
311+
* public var next: ListNode?
312+
* public init() { self.val = 0; self.next = nil; }
313+
* public init(_ val: Int) { self.val = val; self.next = nil; }
314+
* public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
315+
* }
316+
*/
317+
class Solution {
318+
private func add(_ l1: ListNode?, _ l2: ListNode?, _ carry: Int) -> ListNode? {
319+
if l1 == nil && l2 == nil && carry == 0 {
320+
return nil
321+
}
322+
323+
let v1 = l1?.val ?? 0
324+
let v2 = l2?.val ?? 0
325+
326+
let sum = v1 + v2 + carry
327+
let newCarry = sum / 10
328+
let val = sum % 10
329+
330+
let nextNode = add(l1?.next, l2?.next, newCarry)
331+
return ListNode(val, nextNode)
332+
}
333+
334+
func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
335+
return add(l1, l2, 0)
336+
}
337+
}
338+
```
339+
306340
::tabs-end
307341

308342
### Time & Space Complexity
@@ -577,11 +611,49 @@ class Solution {
577611
}
578612
```
579613

614+
```swift
615+
/**
616+
* Definition for singly-linked list.
617+
* public class ListNode {
618+
* public var val: Int
619+
* public var next: ListNode?
620+
* public init() { self.val = 0; self.next = nil; }
621+
* public init(_ val: Int) { self.val = val; self.next = nil; }
622+
* public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
623+
* }
624+
*/
625+
class Solution {
626+
func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
627+
let dummy = ListNode(0)
628+
var cur = dummy
629+
var l1 = l1, l2 = l2
630+
var carry = 0
631+
632+
while l1 != nil || l2 != nil || carry != 0 {
633+
let v1 = l1?.val ?? 0
634+
let v2 = l2?.val ?? 0
635+
636+
let sum = v1 + v2 + carry
637+
carry = sum / 10
638+
let val = sum % 10
639+
cur.next = ListNode(val)
640+
641+
cur = cur.next!
642+
l1 = l1?.next
643+
l2 = l2?.next
644+
}
645+
return dummy.next
646+
}
647+
}
648+
```
649+
580650
::tabs-end
581651

582652
### Time & Space Complexity
583653

584654
* Time complexity: $O(m + n)$
585-
* Space complexity: $O(1)$
655+
* Space complexity:
656+
* $O(1)$ extra space.
657+
* $O(max(m, n))$ for the output list.
586658

587659
> Where $m$ is the length of $l1$ and $n$ is the length of $l2$.

‎articles/anagram-groups.md

+37-2
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,21 @@ class Solution {
125125
}
126126
```
127127

128+
```swift
129+
class Solution {
130+
func groupAnagrams(_ strs: [String]) -> [[String]] {
131+
var res = [String: [String]]()
132+
133+
for s in strs {
134+
let sortedS = String(s.sorted())
135+
res[sortedS, default: []].append(s)
136+
}
137+
138+
return Array(res.values)
139+
}
140+
}
141+
```
142+
128143
::tabs-end
129144

130145
### Time & Space Complexity
@@ -277,11 +292,31 @@ class Solution {
277292
}
278293
```
279294

295+
```swift
296+
class Solution {
297+
func groupAnagrams(_ strs: [String]) -> [[String]] {
298+
var res = [Array<Int>: [String]]()
299+
300+
for s in strs {
301+
var count = [Int](repeating: 0, count: 26)
302+
for c in s {
303+
count[Int(c.asciiValue!) - 97] += 1
304+
}
305+
res[count, default: []].append(s)
306+
}
307+
308+
return Array(res.values)
309+
}
310+
}
311+
```
312+
280313
::tabs-end
281314

282315
### Time & Space Complexity
283316

284317
* Time complexity: $O(m * n)$
285-
* Space complexity: $O(m)$
318+
* Space complexity:
319+
* $O(m)$ extra space.
320+
* $O(m * n)$ space for the output list.
286321

287-
> Where $m$ is the number of strings and $n$ is the length of the longest string.
322+
> Where $m$ is the number of strings and $n$ is the length of the longest string.

‎articles/balanced-binary-tree.md

+123-1
Original file line numberDiff line numberDiff line change
@@ -254,6 +254,43 @@ class Solution {
254254
}
255255
```
256256

257+
```swift
258+
/**
259+
* Definition for a binary tree node.
260+
* public class TreeNode {
261+
* public var val: Int
262+
* public var left: TreeNode?
263+
* public var right: TreeNode?
264+
* public init() { self.val = 0; self.left = nil; self.right = nil; }
265+
* public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
266+
* public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
267+
* self.val = val
268+
* self.left = left
269+
* self.right = right
270+
* }
271+
* }
272+
*/
273+
class Solution {
274+
func isBalanced(_ root: TreeNode?) -> Bool {
275+
guard let root = root else { return true }
276+
277+
let left = height(root.left)
278+
let right = height(root.right)
279+
280+
if abs(left - right) > 1 {
281+
return false
282+
}
283+
284+
return isBalanced(root.left) && isBalanced(root.right)
285+
}
286+
287+
private func height(_ root: TreeNode?) -> Int {
288+
guard let root = root else { return 0 }
289+
return 1 + max(height(root.left), height(root.right))
290+
}
291+
}
292+
```
293+
257294
::tabs-end
258295

259296
### Time & Space Complexity
@@ -521,6 +558,39 @@ class Solution {
521558
}
522559
```
523560

561+
```swift
562+
/**
563+
* Definition for a binary tree node.
564+
* public class TreeNode {
565+
* public var val: Int
566+
* public var left: TreeNode?
567+
* public var right: TreeNode?
568+
* public init() { self.val = 0; self.left = nil; self.right = nil; }
569+
* public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
570+
* public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
571+
* self.val = val
572+
* self.left = left
573+
* self.right = right
574+
* }
575+
* }
576+
*/
577+
class Solution {
578+
func isBalanced(_ root: TreeNode?) -> Bool {
579+
return dfs(root).0
580+
}
581+
582+
private func dfs(_ root: TreeNode?) -> (Bool, Int) {
583+
guard let root = root else { return (true, 0) }
584+
585+
let left = dfs(root.left)
586+
let right = dfs(root.right)
587+
588+
let balanced = left.0 && right.0 && abs(left.1 - right.1) <= 1
589+
return (balanced, 1 + max(left.1, right.1))
590+
}
591+
}
592+
```
593+
524594
::tabs-end
525595

526596
### Time & Space Complexity
@@ -534,7 +604,7 @@ class Solution {
534604
535605
---
536606

537-
## 3. Depth First Search (Stack)
607+
## 3. Iterative DFS
538608

539609
::tabs-start
540610

@@ -866,6 +936,58 @@ class Solution {
866936
}
867937
```
868938

939+
```swift
940+
/**
941+
* Definition for a binary tree node.
942+
* public class TreeNode {
943+
* public var val: Int
944+
* public var left: TreeNode?
945+
* public var right: TreeNode?
946+
* public init() { self.val = 0; self.left = nil; self.right = nil; }
947+
* public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
948+
* public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
949+
* self.val = val
950+
* self.left = left
951+
* self.right = right
952+
* }
953+
* }
954+
*/
955+
class Solution {
956+
func isBalanced(_ root: TreeNode?) -> Bool {
957+
var stack = [TreeNode]()
958+
var node = root
959+
var last: TreeNode? = nil
960+
var depths = [ObjectIdentifier: Int]()
961+
962+
while !stack.isEmpty || node != nil {
963+
if let current = node {
964+
stack.append(current)
965+
node = current.left
966+
} else {
967+
guard let current = stack.last else { break }
968+
if current.right == nil || last === current.right {
969+
stack.removeLast()
970+
971+
let leftDepth = current.left != nil ? depths[ObjectIdentifier(current.left!)] ?? 0 : 0
972+
let rightDepth = current.right != nil ? depths[ObjectIdentifier(current.right!)] ?? 0 : 0
973+
if abs(leftDepth - rightDepth) > 1 {
974+
return false
975+
}
976+
977+
depths[ObjectIdentifier(current)] = 1 + max(leftDepth, rightDepth)
978+
last = current
979+
node = nil
980+
} else {
981+
node = current.right
982+
}
983+
}
984+
}
985+
986+
return true
987+
}
988+
}
989+
```
990+
869991
::tabs-end
870992

871993
### Time & Space Complexity

0 commit comments

Comments
 (0)