liucxu
diff --git a/‎solution/0400-0499/0429.N-ary Tree Level Order Traversal/README.md
Lines changed: 152 additions & 11 deletions b/‎solution/0400-0499/0429.N-ary Tree Level Order Traversal/README.md
Lines changed: 152 additions & 11 deletions
@@ -43,14 +43,28 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“BFS 层次遍历实现”。
+**方法一：BFS**
+
+借助队列，逐层遍历。
+
+时间复杂度 O(n)。
+
+**方法二：DFS**
+
+按深度遍历。
+
+假设当前深度为 i，遍历到的节点为 root。若结果列表 `ans[i]` 不存在，则创建一个空列表放入 ans 中，然后将 `root.val` 放入 `ans[i]`。接着往下一层遍历（root 的子节点）。
+
+时间复杂度 O(n)。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+BFS：
+
 ```python
 """
 # Definition for a Node.
@@ -69,18 +83,47 @@ class Solution:
         q = deque([root])
         while q:
             t = []
-            for _ in range(len(q), 0, -1):
+            for _ in range(len(q)):
                 root = q.popleft()
                 t.append(root.val)
                 q.extend(root.children)
             ans.append(t)
         return ans
 ```
 
+DFS：
+
+```python
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+class Solution:
+    def levelOrder(self, root: 'Node') -> List[List[int]]:
+        def dfs(root, i):
+            if root is None:
+                return
+            if len(ans) <= i:
+                ans.append([])
+            ans[i].append(root.val)
+            for child in root.children:
+                dfs(child, i + 1)
+
+        ans = []
+        dfs(root, 0)
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+BFS：
+
 ```java
 /*
 // Definition for a Node.
@@ -123,33 +166,54 @@ class Solution {
 }
 ```
 
-也可以使用 DFS:
+DFS：
 
 ```java
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
 class Solution {
     public List<List<Integer>> levelOrder(Node root) {
-        List<List<Integer>> res = new ArrayList<>();
-        dfs(root, 0, res);
-        return res;
+        List<List<Integer>> ans = new ArrayList<>();
+        dfs(root, 0, ans);
+        return ans;
     }
 
-    private void dfs(Node root, int level, List<List<Integer>> res) {
+    private void dfs(Node root, int i, List<List<Integer>> ans) {
         if (root == null) {
             return;
         }
-        if (res.size() <= level) {
-            res.add(new ArrayList<>());
+        if (ans.size() <= i) {
+            ans.add(new ArrayList<>());
         }
-        res.get(level++).add(root.val);
+        ans.get(i++).add(root.val);
         for (Node child : root.children) {
-            dfs(child, level, res);
+            dfs(child, i, ans);
         }
     }
 }
 ```
 
 ### **C++**
 
+BFS：
+
 ```cpp
 /*
 // Definition for a Node.
@@ -194,8 +258,50 @@ public:
 };
 ```
 
+DFS：
+
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+public:
+    vector<vector<int>> levelOrder(Node* root) {
+        vector<vector<int>> ans;
+        dfs(root, 0, ans);
+        return ans;
+    }
+
+    void dfs(Node* root, int i, vector<vector<int>>& ans) {
+        if (!root) return;
+        if (ans.size() <= i) ans.push_back({});
+        ans[i++].push_back(root->val);
+        for (Node* child : root->children) dfs(child, i, ans);
+    }
+};
+```
+
 ### **Go**
 
+BFS：
+
 ```go
 /**
  * Definition for a Node.
@@ -227,8 +333,41 @@ func levelOrder(root *Node) [][]int {
 }
 ```
 
+DFS：
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Children []*Node
+ * }
+ */
+
+func levelOrder(root *Node) [][]int {
+	var ans [][]int
+	var dfs func(root *Node, i int)
+	dfs = func(root *Node, i int) {
+		if root == nil {
+			return
+		}
+		if len(ans) <= i {
+			ans = append(ans, []int{})
+		}
+		ans[i] = append(ans[i], root.Val)
+		for _, child := range root.Children {
+			dfs(child, i+1)
+		}
+	}
+	dfs(root, 0)
+	return ans
+}
+```
+
 ### **TypeScript**
 
+BFS：
+
 ```ts
 /**
  * Definition for node.
@@ -262,6 +401,8 @@ function levelOrder(root: Node | null): number[][] {
 }
 ```
 
+DFS：
+
 ```ts
 /**
  * Definition for node.