algorithm-pattern-swift

Author: easyui

.gitignore

@@ -0,0 +1 @@
+.DS_Store

README.md

@@ -0,0 +1,101 @@
+# 算法模板
+
+![来刷题了](https://img.fuiboom.com/img/title.png)
+
+算法模板，最科学的刷题方式，最快速的刷题路径，一个月从入门到 offer，你值得拥有 🐶~
+
+算法模板顾名思义就是刷题的套路模板，掌握了刷题模板之后，刷题也变得好玩起来了~
+
+> 此项目是自己找工作时，从 0 开始刷 LeetCode 的心得记录，通过各种刷题文章、专栏、视频等总结了一套自己的刷题模板。
+>
+> 这个模板主要是介绍了一些通用的刷题模板，以及一些常见问题，如到底要刷多少题，按什么顺序来刷题，如何提高刷题效率等。
+
+## 在线文档
+
+在线文档 Gitbook：[算法模板 🔥](https://greyireland.gitbook.io/algorithm-pattern/)
+
+## 核心内容
+
+### 入门篇 🐶
+
+- [swift 语言入门](./introduction/swift.md)
+- [算法快速入门](./introduction/quickstart.md)
+
+### 数据结构篇 🐰
+
+- [二叉树](./data_structure/binary_tree.md)
+- [链表](./data_structure/linked_list.md)
+- [栈和队列](./data_structure/stack_queue.md)
+- [二进制](./data_structure/binary_op.md)
+
+### 基础算法篇 🐮
+
+- [二分搜索](./basic_algorithm/binary_search.md)
+- [排序算法](./basic_algorithm/sort.md)
+- [动态规划](./basic_algorithm/dp.md)
+
+### 算法思维 🦁
+
+- [递归思维](./advanced_algorithm/recursion.md)
+- [滑动窗口思想](./advanced_algorithm/slide_window.md)
+- [二叉搜索树](./advanced_algorithm/binary_search_tree.md)
+- [回溯法](./advanced_algorithm/backtrack.md)
+
+## 心得体会
+
+文章大部分是对题目的思路介绍，和一些问题的解析，有了思路还是需要自己手动写写的，所以每篇文章最后都有对应的练习题
+
+刷完这些练习题，基本对数据结构和算法有自己的认识体会，基本大部分面试题都能写得出来，国内的 BAT、TMD 应该都不是问题
+
+从 4 月份找工作开始，从 0 开始刷 LeetCode，中间大概花了一个半月(6 周)左右时间刷完 240 题。
+
+![一个半月刷完240题](https://img.fuiboom.com/img/leetcode_time.png)
+
+![刷题记录](https://img.fuiboom.com/img/leetcode_record.png)
+
+开始刷题时，确实是无从下手，因为从序号开始刷，刷到几道题就遇到 hard 的题型，会卡住很久，后面去评论区看别人怎么刷题，也去 Google 搜索最好的刷题方式，发现按题型刷题会舒服很多，基本一个类型的题目，一天能做很多，慢慢刷题也不再枯燥，做起来也很有意思，最后也收到不错的 offer（最后去了宇宙系）。
+
+回到最开始的问题，面试到底要刷多少题，其实这个取决于你想进什么样公司，你定的目标如果是国内一线大厂，个人感觉大概 200 至 300 题基本就满足大部分面试需要了。第二个问题是按什么顺序刷及如何提高效率，这个也是本 repo 的目的，给你指定了一个刷题的顺序，以及刷题的模板，有了方向和技巧后，就去动手吧~ 希望刷完之后，你也能自己总结一套属于自己的刷题模板，有所收获，有所成长~
+
+## 推荐的刷题路径
+
+按此 repo 目录刷一遍，如果中间有题目卡住了先跳过，然后刷题一遍 LeetCode 探索基础卡片，最后快要面试时刷题一遍剑指 offer。
+
+为什么这么要这么刷，因为 repo 里面的题目是按类型归类，都是一些常见的高频题，很有代表性，大部分都是可以用模板加一点变形做出来，刷完后对大部分题目有基本的认识。然后刷一遍探索卡片，巩固一下一些基础知识点，总结这些知识点。最后剑指 offer 是大部分公司的出题源头，刷完面试中基本会遇到现题或者变形题，基本刷完这三部分，大部分国内公司的面试题应该就没什么问题了~
+
+1、 [algorithm-pattern 练习题](https://greyireland.gitbook.io/algorithm-pattern/)
+
+![练习题](https://img.fuiboom.com/img/repo_practice.png)
+
+2、 [LeetCode 卡片](https://leetcode-cn.com/explore/)
+
+![探索卡片](https://img.fuiboom.com/img/leetcode_explore.png)
+
+3、 [剑指 offer](https://leetcode-cn.com/problemset/lcof/)
+
+![剑指offer](https://img.fuiboom.com/img/leetcode_jzoffer.png)
+
+刷题时间可以合理分配，如果打算准备面试了，建议前面两部分 一个半月 （6 周）时间刷完，最后剑指 offer 半个月刷完，边刷可以边投简历进行面试，遇到不会的不用着急，往模板上套就对了，如果面试管给你提示，那就好好做，不要错过这大好机会~
+
+> 注意点：如果为了找工作刷题，遇到 hard 的题如果有思路就做，没思路先跳过，先把基础打好，再来刷 hard 可能效果会更好~
+
+## 面试资源
+
+分享一些计算机的经典书籍，大部分对面试应该都有帮助，强烈推荐 🌝
+
+[我看过的 100 本书](https://github.com/greyireland/awesome-programming-books-1)
+
+## 更新计划
+
+持续更新中，觉得还可以的话点个 **star** 收藏呀 ⭐️~
+
+【 Github 】[https://github.com/greyireland/algorithm-pattern](https://github.com/greyireland/algorithm-pattern) ⭐️
+
+## 完成打卡
+
+完成计划之后，可以提交 Pull requests，在下面添加自己的项目仓库，完成自己的算法模板打卡呀~
+
+| 完成 | 用户                                              | 项目地址                                                            |
+| ---- | ------------------------------------------------- | ------------------------------------------------------------------- |
+| ✅   | [wardseptember](https://github.com/wardseptember) | [notes(Java 实现)](https://github.com/wardseptember/notes)          |
+| ✅   | [dashidhy](https://github.com/dashidhy) | [algorithm-pattern-python(Python 实现)](https://github.com/dashidhy/algorithm-pattern-python) |

SUMMARY.md

@@ -0,0 +1,26 @@
+# 算法模板
+
+## 入门篇
+
+- [swift 语言入门](introduction/swift.md)
+- [算法快速入门](introduction/quickstart.md)
+
+## 数据结构篇
+
+- [二叉树](data_structure/binary_tree.md)
+- [链表](data_structure/linked_list.md)
+- [栈和队列](data_structure/stack_queue.md)
+- [二进制](data_structure/binary_op.md)
+
+## 基础算法篇
+
+- [二分搜索](basic_algorithm/binary_search.md)
+- [排序算法](basic_algorithm/sort.md)
+- [动态规划](basic_algorithm/dp.md)
+
+## 算法思维
+
+- [递归思维](advanced_algorithm/recursion.md)
+- [滑动窗口思想](advanced_algorithm/slide_window.md)
+- [二叉搜索树](advanced_algorithm/binary_search_tree.md)
+- [回溯法](advanced_algorithm/backtrack.md)

TODO.md

@@ -0,0 +1,8 @@
+# 计划
+
+## v1
+
+- [ ] 完善文档细节
+- [ ] 工程实现用到的算法解析
+- [ ] 周赛计划
+- [ ] 面试体系计划

advanced_algorithm/backtrack.md

@@ -0,0 +1,205 @@
+# 回溯法
+
+## 背景
+
+回溯法（backtrack）常用于遍历列表所有子集，是 DFS 深度搜索一种，一般用于全排列，穷尽所有可能，遍历的过程实际上是一个决策树的遍历过程。时间复杂度一般 O(N!)，它不像动态规划存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。
+
+## 模板
+
+```swift
+result = []
+func backtrack(选择列表,路径):
+    if 满足结束条件:
+        result.add(路径)
+        return
+    for 选择 in 选择列表:
+        做选择
+        backtrack(选择列表,路径)
+        撤销选择
+```
+
+核心就是从选择列表里做一个选择，然后一直递归往下搜索答案，如果遇到路径不通，就返回来撤销这次选择。
+
+## 示例
+
+### [subsets](https://leetcode-cn.com/problems/subsets/)
+
+> 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
+
+遍历过程
+
+![image.png](https://img.fuiboom.com/img/backtrack.png)
+
+```swift
+//回溯
+//https://leetcode-cn.com/problems/subsets/solution/swift-zi-ji-hui-su-by-hu-cheng-he-da-bai-sha/
+//执行用时：8 ms, 在所有 Swift 提交中击败了97.96%的用户
+//内存消耗：13.5 MB, 在所有 Swift 提交中击败了93.90%的用户
+func subsets(_ nums: [Int]) -> [[Int]] {
+    var res = [[Int]]()
+    
+    func backtrack(start :Int, track: inout [Int]){
+        res.append(track)
+        for index in start..<nums.count {
+            track.append(nums[index])
+            backtrack(start: index+1, track: &track)
+            track.popLast()
+        }
+    }
+    
+    var items = [Int]()
+    backtrack(start: 0, track: &items)
+    
+    return res
+}
+
+//迭代
+//https://leetcode-cn.com/problems/subsets/solution/swift-zi-ji-die-dai-by-hu-cheng-he-da-bai-sha/
+//执行用时：12 ms, 在所有 Swift 提交中击败了76.35%的用户
+//内存消耗：13.5 MB, 在所有 Swift 提交中击败了93.90%的用户
+func subsets_a(_ nums: [Int]) -> [[Int]] {
+    var res = [[Int]]()
+    res.append([Int]())
+    
+    for num in nums {
+        var list = [[Int]]()
+        for item in res {
+            list.append(item + [num])
+        }
+        res.append(contentsOf: list)
+    }
+    
+    return res
+}
+```
+
+### [subsets-ii](https://leetcode-cn.com/problems/subsets-ii/)
+
+> 给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。说明：解集不能包含重复的子集。
+
+```swift
+//https://leetcode-cn.com/problems/subsets-ii/solution/swift-90-zi-ji-iihui-su-by-hu-cheng-he-da-bai-sha/
+//执行用时：12 ms, 在所有 Swift 提交中击败了100.00%的用户
+//内存消耗：14 MB, 在所有 Swift 提交中击败了87.50%的用户
+func subsetsWithDup(_ nums: [Int]) -> [[Int]] {
+    var res = [[Int]]()
+    let sortedNums = nums.sorted()
+    
+    func backtrack(start :Int, track: inout [Int]){
+        res.append(track)
+        for index in start..<sortedNums.count {
+            if index > start && sortedNums[index] == sortedNums[index - 1]{
+                continue
+            }
+            track.append(sortedNums[index])
+            backtrack(start: index+1, track: &track)
+            track.popLast()
+        }
+    }
+    
+    var items = [Int]()
+    backtrack(start: 0, track: &items)
+    
+    return res
+}
+```
+
+### [permutations](https://leetcode-cn.com/problems/permutations/)
+
+> 给定一个   没有重复   数字的序列，返回其所有可能的全排列。
+
+思路：需要记录已经选择过的元素，满足条件的结果才进行返回
+
+```swift
+//https://leetcode-cn.com/problems/permutations/solution/swift-46-quan-pai-lie-hui-su-tong-shi-ji-lu-shi-yo/
+//执行用时：28 ms, 在所有 Swift 提交中击败了74.77%的用户
+//内存消耗：13.4 MB, 在所有 Swift 提交中击败了98.28%的用户
+func permute(_ nums: [Int]) -> [[Int]] {
+    var res = [[Int]]()
+    let count = nums.count
+    var used = [Int :Bool]()
+    
+    func backtrack(track: inout [Int]){
+        if track.count == count{
+            res.append(track)
+        }
+        for num in nums {
+            if used[num] ?? false {
+                continue
+            }
+            used[num] = true
+            track.append(num)
+            backtrack(track: &track)
+            used[num] = false
+            track.popLast()
+        }
+    }
+    
+    var items = [Int]()
+    backtrack( track: &items)
+    
+    return res
+}
+```
+
+### [permutations-ii](https://leetcode-cn.com/problems/permutations-ii/)
+
+> 给定一个可包含重复数字的序列，返回所有不重复的全排列。
+
+```swift
+//https://leetcode-cn.com/problems/permutations-ii/solution/swift-47-quan-pai-lie-iipai-xu-hou-hui-su-you-hua-/
+//执行用时：64 ms, 在所有 Swift 提交中击败了43.59%的用户
+//内存消耗：14.5 MB, 在所有 Swift 提交中击败了89.47%的用户
+func permuteUnique(_ nums: [Int]) -> [[Int]] {
+    var res = [[Int]]()
+    let count = nums.count
+    var used = [Int :Bool]()
+    let sortedNums = nums.sorted()
+
+    
+    func backtrack(track: inout [Int]){
+        if track.count == count{
+            res.append(track)
+        }
+        for (index,num) in sortedNums.enumerated() {
+            if used[index] ?? false {
+                continue
+            }
+            
+            // if index > 0 && sortedNums[index] == sortedNums[index - 1] && (used[index - 1] ?? false)  {
+            //     continue
+            // }
+            //优化：提前剪枝
+            if index > 0 && sortedNums[index] == sortedNums[index - 1] && !(used[index - 1]!)  {
+                continue
+            }
+            
+            used[index] = true
+            track.append(num)
+            backtrack(track: &track)
+            used[index] = false
+            track.popLast()
+        }
+    }
+    
+    var items = [Int]()
+    backtrack( track: &items)
+    
+    return res
+}
+```
+
+## 练习
+
+- [ ] [subsets](https://leetcode-cn.com/problems/subsets/)
+- [ ] [subsets-ii](https://leetcode-cn.com/problems/subsets-ii/)
+- [ ] [permutations](https://leetcode-cn.com/problems/permutations/)
+- [ ] [permutations-ii](https://leetcode-cn.com/problems/permutations-ii/)
+
+挑战题目
+
+- [ ] [combination-sum](https://leetcode-cn.com/problems/combination-sum/)
+- [ ] [letter-combinations-of-a-phone-number](https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)
+- [ ] [palindrome-partitioning](https://leetcode-cn.com/problems/palindrome-partitioning/)
+- [ ] [restore-ip-addresses](https://leetcode-cn.com/problems/restore-ip-addresses/)
+- [ ] [permutations](https://leetcode-cn.com/problems/permutations/)