leecode 1609. 奇偶树

如果一棵二叉树满足下述几个条件，则可以称为 奇偶树 ：

1. 二叉树根节点所在层下标为 0 ，根的子节点所在层下标为 1 ，根的孙节点所在层下标为 2 ，依此类推。
2. 偶数下标 层上的所有节点的值都是 奇 整数，从左到右按顺序 严格递增
3. 奇数下标 层上的所有节点的值都是 偶 整数，从左到右按顺序 严格递减

给你二叉树的根节点，如果二叉树为 奇偶树 ，则返回 true ，否则返回 false 。

示例 1：

输入：root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
输出：true
解释：每一层的节点值分别是：
0 层：[1]
1 层：[10,4]
2 层：[3,7,9]
3 层：[12,8,6,2]
由于 0 层和 2 层上的节点值都是奇数且严格递增，而 1 层和 3 层上的节点值都是偶数且严格递减，因此这是一棵奇偶树。

示例 2：

输入：root = [5,4,2,3,3,7]
输出：false
解释：每一层的节点值分别是：
0 层：[5]
1 层：[4,2]
2 层：[3,3,7]
2 层上的节点值不满足严格递增的条件，所以这不是一棵奇偶树。

示例 3：

输入：root = [5,9,1,3,5,7]
输出：false
解释：1 层上的节点值应为偶数。

示例 4：

输入：root = [1]
输出：true

示例 5：

输入：root = [11,8,6,1,3,9,11,30,20,18,16,12,10,4,2,17]
输出：true

解题思路
二叉树的遍历方法：1.先序遍历 2.中序遍历 3.后序遍历 4.深度优先搜索 5.广度优先搜索（层次遍历）
由题意可知：要对每层的节点进行合法性判断：奇偶性、单调性，所以可采用层次遍历。
遍历每层节点时，用flag标记层数，用list列表存储每层节点的值，从而进行合法性判断，返回最终的结果。

/**
 * 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 {
    public boolean isEvenOddTree(TreeNode root) {
        Queue<TreeNode> queue=new LinkedList<>();//建立层次遍历的队列  
        int flag=0,len,tem;//flag纪录二叉树层数
        queue.add(root);//将叶子结点加入到队列中
        while(queue.size()!=0)//对二叉树进行层次遍历
        {
            List<Integer> list=new LinkedList<>();//建立列表存储每层节点的值
            len=queue.size();//纪录队列的长度（大小）
            for(int i=0;i<len;i++)//对二叉树的每层节点进行遍历
            {
                TreeNode temp=queue.poll();//取出队列中的第一个元素，并在队列中删除
                list.add(temp.val);//将节点的值加入到列表中
                if(temp.left!=null)
                    queue.add(temp.left);
                if(temp.right!=null)//如果左右孩子非空，就将节点的左右孩子加入到队列中
                    queue.add(temp.right);
            }
            tem=flag%2==0?isQ(list):isO(list);
        //tem变量纪录下对列表中元素的判断，0->非法  1->合法
        //flag:0/2/4/6/..->节点的值：奇数、严格递增     1/3/5/7/...->节点的值：偶数、严格递减
            if(tem==0)
                return false;
            flag++;
        }
        return true;
    }
    public static int isQ(List<Integer> list)//对偶数层进行判断，合法则返回1，非法返回0
    {
        for(int i=0;i<list.size();i++)//对奇偶性进行判断
            if(list.get(i)%2==0)
                return 0;     
        for(int i=0;i<(list.size()-1);i++)//对单调性进行判断
            if(list.get(i)>=list.get(i+1))
                return 0;  
        return 1;
    }
    public static int isO(List<Integer> list)//对奇数层进行判断，合法则返回1，非法返回0
    {
        for(int i=0;i<list.size();i++)
            if(list.get(i)%2==1)
                return 0;     
        for(int i=0;i<list.size()-1;i++)
            if(list.get(i)<=list.get(i+1))
                return 0;  
        return 1;
    }
}