diff --git a/problems/0106.从中序与后序遍历序列构造二叉树.md b/problems/0106.从中序与后序遍历序列构造二叉树.md
index 487e4f7d..40d75983 100644
--- a/problems/0106.从中序与后序遍历序列构造二叉树.md
+++ b/problems/0106.从中序与后序遍历序列构造二叉树.md
@@ -684,7 +684,7 @@ class Solution:
         root.right = self.buildTree(preorder_right, inorder_right)
 
         return root
-``` 
+```
 
 106.从中序与后序遍历序列构造二叉树
 
@@ -716,7 +716,7 @@ class Solution:
         root.right = self.buildTree(inorder_right, postorder_right)
 
         return root 
-``` 
+```
 
 ## Go
 
@@ -816,6 +816,7 @@ var buildTree = function(preorder, inorder) {
 
 ## C
 106 从中序与后序遍历序列构造二叉树
+
 ```c
 int linearSearch(int* arr, int arrSize, int key) {
     int i;
@@ -847,6 +848,7 @@ struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int po
 ```
 
 105 从前序与中序遍历序列构造二叉树
+
 ```c
 struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize){
     // 递归结束条件：传入的数组大小为0
@@ -889,5 +891,100 @@ struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int in
 }
 ```
 
+## Swift
+
+105 从前序与中序遍历序列构造二叉树
+
+```swift
+class Solution {
+    func buildTree(_ preorder: [Int], _ inorder: [Int]) -> TreeNode? {
+        return helper(preorder: preorder,
+                      preorderBegin: 0,
+                      preorderEnd: preorder.count,
+                      inorder: inorder,
+                      inorderBegin: 0,
+                      inorderEnd: inorder.count)
+    }
+    
+    func helper(preorder: [Int], preorderBegin: Int, preorderEnd: Int, inorder: [Int], inorderBegin: Int, inorderEnd: Int) -> TreeNode? {
+        if preorderBegin == preorderEnd {
+            return nil
+        }
+        
+        // 前序遍历数组的第一个元素作为分割点
+        let rootValue = preorder[preorderBegin]
+        let root = TreeNode(rootValue)
+        
+        
+        if preorderEnd - preorderBegin == 1 {
+            return root
+        }
+        
+        var index = 0 // 从中序遍历数组中找到根节点的下标
+        if let ind = inorder.firstIndex(of: rootValue) {
+            index = ind
+        }
+        
+        // 递归
+        root.left = helper(preorder: preorder,
+                           preorderBegin: preorderBegin + 1,
+                           preorderEnd: preorderBegin + 1 + index - inorderBegin,
+                           inorder: inorder,
+                           inorderBegin: inorderBegin,
+                           inorderEnd: index)
+        root.right = helper(preorder: preorder,
+                            preorderBegin: preorderBegin + 1 + index - inorderBegin,
+                            preorderEnd: preorderEnd,
+                            inorder: inorder,
+                            inorderBegin: index + 1,
+                            inorderEnd: inorderEnd)
+        return root
+    }
+}
+```
+
+106 从中序与后序遍历序列构造二叉树
+
+```swift
+class Solution_0106 {
+    func buildTree(inorder: [Int], inorderBegin: Int, inorderEnd: Int, postorder: [Int], postorderBegin: Int, postorderEnd: Int) -> TreeNode? {
+        if postorderEnd - postorderBegin < 1 {
+            return nil
+        }
+        
+        // 后序遍历数组的最后一个元素作为分割点
+        let rootValue = postorder[postorderEnd - 1]
+        let root = TreeNode(rootValue)
+        
+        if postorderEnd - postorderBegin == 1 {
+            return root
+        }
+        
+        // 从中序遍历数组中找到根节点的下标
+        var delimiterIndex = 0
+        if let index = inorder.firstIndex(of: rootValue) {
+            delimiterIndex = index
+        }
+        
+        root.left = buildTree(inorder: inorder,
+                              inorderBegin: inorderBegin,
+                              inorderEnd: delimiterIndex,
+                              postorder: postorder,
+                              postorderBegin: postorderBegin,
+                              postorderEnd: postorderBegin + (delimiterIndex - inorderBegin))
+        
+        root.right = buildTree(inorder: inorder,
+                               inorderBegin: delimiterIndex + 1,
+                               inorderEnd: inorderEnd,
+                               postorder: postorder,
+                               postorderBegin: postorderBegin + (delimiterIndex - inorderBegin),
+                               postorderEnd: postorderEnd - 1)
+        return root
+    }
+}
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>