給你一棵二叉樹的根節點 root ，樹中有 n 個節點，每個節點都有一個不同於其他節點且處於 1 到 n 之間的值。

另給你一個由 n 個值組成的行程式列 voyage ，表示 預期 的二叉樹 先序遍歷 結果。

通過交換節點的左右子樹，可以 翻轉 該二叉樹中的任意節點。例，翻轉節點 1 的效果如下：

請翻轉 最少 的樹中節點，使二叉樹的 先序遍歷 與預期的遍歷行程voyage相匹配 。

如果可以，則返回 翻轉的 所有節點的值的列表。你可以按任何順序返回答案。如果不能，則返回列表 [-1]。

示例 1

輸入：root = [1,2], voyage = [2,1]
輸出：[-1]
解釋：翻轉節點無法令先序遍歷匹配預期行程。
示例 2：

輸入：root = [1,2,3], voyage = [1,3,2]
輸出：[1]
解釋：交換節點 2 和 3 來翻轉節點 1 ，先序遍歷可以匹配預期行程。
示例 3：

輸入：root = [1,2,3], voyage = [1,2,3]
輸出：[]
解釋：先序遍歷已經匹配預期行程，所以不需要翻轉節點。

提示：

樹中的節點數目為 n
n == voyage.length
1 <= n <= 100
1 <= Node.val, voyage[i] <= n
樹中的所有值 互不相同
voyage 中的所有值 互不相同

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/flip-binary-tree-to-match-preorder-traversal
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

1:前序遍歷二叉樹，返回值為布林型，true表示其子節點的遍歷順序為陣列的順序。否則為false.

2:先遍歷左子樹，

若返回turn，則表示順序正確，接著遍歷右子樹，

若返回ture，表示正確。直接返回，不再往下走程式。

若為flase，則反轉。
3:若走到此處，表示沒有反轉的樹不符合陣列順序，則反轉樹。

把反轉的記錄新增到list中。

先遍歷右子樹，邏輯同上一步驟。

4:最終判斷時返回值，若是true，返回list，否則，返回-1.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 
 
*/
class Solution {
    private int n = 0;

    public List<Integer> flipMatchVoyage(TreeNode root, int[] voyage) {
        List<Integer> list = new ArrayList<>();
        boolean b = find(root, voyage, list);
        if (b) {
            return list;
        }
        list = new ArrayList<>();
        list.add(-1);
        return list;
    }

    private boolean find(TreeNode root, int[] voyage, List<Integer> list) {
        if (root == null) {
            return true;
        }
        if (n == voyage.length || root.val != voyage[n]) {
            return false;
        }
        n++;
        if (find(root.left, voyage, list) && find(root.right, voyage, list)) {
            return true;
        }
        list.add(root.val);
        if (find(root.right, voyage, list) && find(root.left, voyage, list)) {
            return true;
        }
        n--;
        list.remove(list.size() - 1);
        return false;
    }
}