求二叉树中从根结点到叶子结点的路径；采用先序遍历输出所有从叶子结点到根结点的逆路径，并输出第一条最长的逆路径，采用后序非递归遍历输出所有从叶子结点到根结点的逆路径，采用层次遍历方法输出所有从叶子结点到根结点的逆路径

二叉树中从根结点到叶子结点的路径可以采用深度优先遍历（DFS）中的前序遍历（先访问根节点，再访问左子树和右子树）实现，当遍历到叶子节点时，将路径加入结果中。具体实现可以参考以下代码：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def findPaths(root):
    res = [] # 存储所有路径

    def dfs(node, path):
        if not node:
            return
        if not node.left and not node.right: # 叶子节点
            res.append(path + [node.val])
            return
        dfs(node.left, path + [node.val])
        dfs(node.right, path + [node.val])

    dfs(root, [])
    return res

采用先序遍历输出所有从叶子结点到根结点的逆路径，并输出第一条最长的逆路径，可以修改上述代码，在遍历到叶子节点时，将路径逆序后加入结果中。同时记录路径长度，找到最长的路径。具体实现可以参考以下代码：

def findPaths(root):
    res = [] # 存储所有路径
    longest_path = [] # 存储最长的逆路径
    max_length = 0 # 最长逆路径的长度

    def dfs(node, path):
        if not node:
            return
        if not node.left and not node.right: # 叶子节点
            rev_path = path + [node.val]
            rev_path.reverse()
            res.append(rev_path)
            if len(rev_path) > max_length:
                max_length = len(rev_path)
                longest_path[:] = rev_path # 注意要使用切片复制

        dfs(node.left, path + [node.val])
        dfs(node.right, path + [node.val])

    dfs(root, [])
    return res, longest_path

采用后序非递归遍历输出所有从叶子结点到根结点的逆路径可以使用栈来实现。具体思路是，先用后序遍历遍历整棵树，同时在遍历的过程中记录当前路径。当遍历到叶子节点时，将路径逆序后压入栈中。遍历完整棵树后，弹出栈中的元素，即可得到所有从叶子节点到根节点的逆路径。具体实现可以参考以下代码：

def postorderTraversal(root):
    res = []
    stack = []
    prev = None
    while root or stack:
        while root:
            stack.append(root)
            root = root.left
        root = stack[-1]
        if not root.right or root.right == prev:
            stack.pop()
            res.append(root)
            prev = root
            root = None
        else:
            root = root.right
    return res

def findPaths(root):
    res = [] # 存储所有路径
    stack = [] # 存储从叶子节点到根节点的逆路径

    def reversePath(path):
        rev_path = path[:]
        rev_path.reverse()
        return rev_path

    for node in postorderTraversal(root):
        if not node.left and not node.right: # 叶子节点
            stack.append(node)
        else:
            while stack and stack[-1].val not in (node.left.val, node.right.val):
                stack.pop()
            if stack:
                path = [n.val for n in stack]
                path.append(node.val)
                res.append(reversePath(path))
            stack.append(node)

    return res

采用层次遍历方法输出所有从叶子结点到根结点的逆路径可以利用队列和字典来实现。具体思路是，先用层次遍历遍历整棵树，同时在遍历的过程中记录每个节点的父节点。当遍历到叶子节点时，利用字典回溯到根节点，即可得到从叶子节点到根节点的逆路径。具体实现可以参考以下代码：

def findPaths(root):
    res = [] # 存储所有路径
    queue = [(root, None)] # 存储节点和其父节点的元组
    parent = {} # 存储每个节点的父节点

    while queue:
        node, p = queue.pop(0)
        if not node.left and not node.right: # 叶子节点
            path = [node.val]
            while node:
                path.append(node.val)
                node = parent.get(node)
            res.append(path[:-1][::-1])
        if node.left:
            parent[node.left] = node
            queue.append((node.left, node))
        if node.right:
            parent[node.right] = node
            queue.append((node.right, node))

    return res