数据结构（Python实现）------ N叉树
数据结构（Python实现）------N叉树
N叉树的经典递归解法
基本概念
树的遍历
一棵二叉树可以按照前序、中序、后序或者层序来进行遍历。在这些遍历方法中，前序遍历、后序遍历和层序遍历同样可以运用到N叉树中。
回顾 - 二叉树的遍历
前序遍历 - 首先访问根节点，然后遍历左子树，最后遍历右子树；
中序遍历 - 首先遍历左子树，然后访问根节点，最后遍历右子树；
后序遍历 - 首先遍历左子树，然后遍历右子树，最后访问根节点；
层序遍历 - 按照从左到右的顺序，逐层遍历各个节点。
请注意，N叉树的中序遍历没有标准定义，中序遍历只有在二叉树中有明确的定义。尽管我们可以通过几种不同的方法来定义N叉树的中序遍历，但是这些描述都不是特别贴切，并且在实践中也不常用到，所以我们暂且跳过N叉树中序遍历的部分。
把上述关于二叉树遍历转换为N叉树遍历，我们只需把如下表述:
遍历左子树… 遍历右子树…
变为:
对于每个子节点:
通过递归地调用遍历函数来遍历以该子节点为根的子树
我们假设for循环将会按照各个节点在数据结构中的顺序进行遍历：通常按照从左到右的顺序，如下所示。
N叉树遍历示例
1.前序遍历
在N叉树中，前序遍历指先访问根节点，然后逐个遍历以其子节点为根的子树。
例如，上述三叉树的前序遍历是: A->B->C->E->F->D->G.
2.后序遍历
在N叉树中，后序遍历指前先逐个遍历以根节点的子节点为根的子树，最后访问根节点。
例如，上述三叉树的后序遍历是: B->E->F->C->G->D->A.
3.层序遍历
N叉树的层序遍历与二叉树的一致。通常，当我们在树中进行广度优先搜索时，我们将按层序的顺序进行遍历。
例如，上述三叉树的层序遍历是: A->B->C->D->E->F->G.
Python实现
N-ary Tree Preorder Traversal
栈实现：
# Definition for a Node.
class Node(object):
def __init__(self, val=None, children=None):
self.val = val
self.children = children
class Solution(object):
def preorder(self, root):
"""
:type root: Node
:rtype: List[int]
"""
if not root:
return []
stack,ans = [root],[]
while stack:
node = stack.pop()
ans.append(node.val)
if node.children:
stack.extend(reversed(node.children))
return ans
递归实现：
class Solution(object):
def preorder(self, root):
"""
:type root: Node
:rtype: List[int]
"""
if not root:
return []
ans = [root.val]
for c in root.children:
ans += self.preorder(c)
return ans
N-ary Tree Postorder Traversal
# Definition for a Node.
class Node(object):
def __init__(self, val=None, children=None):
self.val = val
self.children = children
class Solution(object):
def postorder(self, root):
"""
:type root: Node
:rtype: List[int]
"""
if root is None:
return root
stack = [root]
res = []
while stack:
node = stack.pop()
for child in node.children[::1]:
stack.append(child)
res.insert(0,node.val)
return res
N叉树的层序遍历
# Definition for a Node.
class Node(object):
def __init__(self, val=None, children=None):
self.val = val
self.children = children
class Solution(object):
def levelOrder(self, root):
"""
:type root: Node
:rtype: List[List[int]]
"""
if not root:
return []
queue = []
res = []
queue.append(root)
while len(queue):
l = len(queue)
sub = []#保存每层节点的值
for i in range(l):
current = queue.pop(0)
sub.append(current.val)
for child in current.children:
queue.append(child)
res.append(sub)
return res
N叉树的经典递归解法
基本概念
经典递归法
我们在之前的章节中讲过如何运用递归法解决二叉树问题。在这篇文章中，我们着重介绍如何将这个思想引入到N叉树中。
在阅读以下内容之前，请确保你已阅读过 运用递归解决树的问题 这篇文章。
1. "自顶向下"的解决方案
"自顶向下"意味着在每个递归层次上，我们首先访问节点以获得一些值，然后在调用递归函数时，将这些值传给其子节点。
一个典型的 “自顶向下” 函数 top_down(root, params) 的工作原理如下：
1. 对于 null 节点返回一个特定值
2. 如果有需要，对当前答案 answer 进行更新 // answer <-- params
3. for each child node root.children[k]:
4. ans[k] = top_down(root.children[k], new_params[k]) // new_params <-- root.val, params
5. 如果有需要，返回答案 answer // answer <-- all ans[k]
2. "自底向上"的解决方案
“自底向上” 意味着在每个递归层次上，我们首先为每个子节点递归地调用函数，然后根据返回值和根节点本身的值给出相应结果。
一个典型的 “自底向上” 函数 bottom_up(root) 的工作原理如下：
1.对于 null 节点返回一个特定值
2.for each child node root.children[k]:
3. ans[k] = bottom_up(root.children[k]) // 为每个子节点递归地调用函数
4. 返回答案 answer // answer <- root.val, all ans[k]
Python实现
Maximum Depth of N-ary Tree
# Definition for a Node.
class Node(object):
def __init__(self, val=None, children=None):
self.val = val
self.children = children
class Solution(object):
def maxDepth(self, root):
"""
:type root: Node
:rtype: int
"""
if not root:
return 0
if not root.children:
return 1
return max(self.maxDepth(child) for child in root.children)+1
