Question 1609 has been solved.

Author: pinarkizilarslan

Q-1609 - Even Odd Tree/1609.cpp

@@ -0,0 +1,53 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution
+{
+public:
+    void get_data(bool &result, TreeNode* node, vector<int> &array, int level){
+        if(node==NULL){
+            return;
+        }
+        if(level%2==0 && (node->val)%2==0){
+            result=false;
+            return;
+        }
+        if(level%2!=0 && (node->val)%2!=0){
+            result=false;
+            return;
+        }
+        if(level==array.size()){
+            array.push_back(node->val);
+        }
+        else if(level%2==0){
+            if(array[level]>=node->val){
+                result=false;
+                return;
+            }
+            array[level]=node->val;
+        }
+        else if (level %2 !=0){
+            if(array[level]<=node->val){
+                result=false;
+                return;
+            }
+            array[level]=node->val;
+        }
+        get_data(result, node->left, array, level+1);
+        get_data(result, node->right, array, level+1);        
+    }
+    bool isEvenOddTree(TreeNode* root) {
+        vector<int> array;
+        bool result=true;
+        get_data(result, root, array, 0);
+        return result;    
+    }
+};

Q-1609 - Even Odd Tree/1609.py

@@ -0,0 +1,43 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isEvenOddTree(self, root: TreeNode) -> bool:        
+        queue = []        
+        odd = lambda x: (x % 2 == 1)
+        even = lambda x: (x % 2 == 0)        
+        levelCount = 0        
+        
+        if (root):
+            queue = [(root)]  
+        while (queue):            
+            newQueue = []
+            temp = None            
+            level = False 
+            if (even(levelCount)):
+                 level = True            
+            for idx, node in enumerate(queue):
+                if (level and not odd(node.val)):
+                    return False                
+                if (not level and not even(node.val)):
+                    return False
+                if (idx == 0):
+                    temp= float('inf')
+                    if even(levelCount):
+                        temp = float('-inf') 
+                else:                    
+                    if (even(levelCount) and temp >= node.val):
+                        return False
+                    elif (odd(levelCount) and temp <= node.val):
+                        return False                
+                temp = node.val
+                if (node.left):
+                    newQueue.append(node.left)
+                if (node.right):
+                    newQueue.append(node.right)
+            queue = newQueue
+            levelCount += 1            
+        return True