你可不可以
成为我的main函数
做我此生必须有
且只能有一个的入口
——————————
我愿为自己加上private
在你的class中只有
你能调用
——————————————代 码 如 诗 。
Given an array of integers, every element appears twice except for one. Find that single one.
Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
|
1 |
return nums.reduce(0) { $0 ^ $1 } |
Say you have an array for which the ith element is the price of a given stock on day i.
If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
|
1 2 3 4 5 6 7 8 9 10 |
func maxProfit(_ prices: [Int]) -> Int { if prices.count < 2 { return 0 } var p = prices[0], m = 0 for i in 1..<prices.count { m = max(m, prices[i] - p) p = min(p, prices[i]) } return m } |
Given a binary tree, flatten it to a linked list in-place.
For example, given the following tree:
|
1 2 3 4 5 |
1 / \ 2 5 / \ \ 3 4 6 |
The flattened tree should look like:
|
1 2 3 4 5 6 7 8 9 10 11 |
1 \ 2 \ 3 \ 4 \ 5 \ 6 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
func flatten(_ root: TreeNode?) { if let p = root { flatten(p.left) flatten(p.right) if let l = p.left { if let r = p.right { var lr = l while lr.right != nil { lr = lr.right! } lr.right = r } p.right = l p.left = nil } } } |
Given a binary tree, find its maximum depth.
The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
|
1 |
return root == nil ? 0 : 1 + max(maxDepth(root?.left), maxDepth(root?.right)) |
Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).
For example:
Given binary tree {3,9,20,#,#,15,7},
3
/ \
9 20
/ \
15 7
return its level order traversal as:
[
[3],
[9,20],
[15,7]
]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
func levelOrder(_ root: TreeNode?) -> [[Int]] { guard let root = root else { return [] } var q = [TreeNode](), lists = [[Int]]() q.append(root) while !q.isEmpty { lists.append(q.map { $0.val }) q = q.reduce([]) { l, t in l + [t.left, t.right] }.compactMap({$0}) } return lists } |
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
For example, this binary tree is symmetric:
1
/ \
2 2
/ \ / \
3 4 4 3
But the following is not:
1
/ \
2 2
\ \
3 3
Note:
Bonus points if you could solve it both recursively and iteratively.
|
1 2 3 4 5 6 7 8 9 10 11 |
func isSymmetricTree(_ p: TreeNode?, _ q: TreeNode?) -> Bool { if let p = p, let q = q { return p.val == q.val && isSymmetricTree(p.left, q.right) && isSymmetricTree(p.right, q.left) } else { return p == nil && q == nil } } func isSymmetric(_ root: TreeNode?) -> Bool { return isSymmetricTree(root?.left, root?.right) } |