Tree Leetcode Solutions

4 min readAug 23, 2026

Binary Tree Inorder Traversal:
https://leetcode.com/problems/binary-tree-inorder-traversal/description

/**
 * 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 {
    List<Integer> result = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {

        inOrderDFS(root);

        return result;
    }

    public void inOrderDFS(TreeNode node){
        if(node == null)
            return;

        inOrderDFS(node.left);

        result.add(node.val);

        inOrderDFS(node.right);
    }
}

Binary Tree Preorder Traversal:
https://leetcode.com/problems/binary-tree-preorder-traversal/description/

/**
 * 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 {
    List<Integer> result = new ArrayList<>(); 
    public List<Integer> preorderTraversal(TreeNode root) {
      preOrderDFS(root);

        return result;
    }

    public void preOrderDFS(TreeNode node){
        if(node == null)
            return;

        result.add(node.val);

        preOrderDFS(node.left);

        preOrderDFS(node.right);  
    }
}

Binary Tree Postorder Traversal:
https://leetcode.com/problems/binary-tree-preorder-traversal/description/

/**
 * 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 {
    List<Integer> result = new ArrayList<>(); 
    public List<Integer> preorderTraversal(TreeNode root) {
      preOrderDFS(root);

        return result;
    }

    public void preOrderDFS(TreeNode node){
        if(node == null)
            return;

        result.add(node.val);

        preOrderDFS(node.left);

        preOrderDFS(node.right);  
    }
}

Same Tree:
https://leetcode.com/problems/same-tree/description

/**
 * 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 isSameTree(TreeNode p, TreeNode q) {

        boolean result = sameTreeDFS(p, q);

        return result;
    }

    public boolean sameTreeDFS (TreeNode n1, TreeNode n2){

        if(n1 == null && n2 == null) 
            return true;

        if(n1 == null && n2 != null)
            return false;

        if(n1 != null && n2 == null)
            return false;
        
        if(n1.val == n2.val){
            
            boolean ans1 = sameTreeDFS(n1.left, n2.left);

            if(ans1==false)
                return ans1;

            boolean ans2 = sameTreeDFS(n1.right, n2.right);

            if(ans1==ans2)
                return true;
            else
                return false;
        }
        return false;
    }

}

Get Nivetharavi’s stories in your inbox
Join Medium for free to get updates from this writer.
Remember me for faster sign in
Sum of Left Leaves:
https://leetcode.com/problems/sum-of-left-leaves/description/


/**
 * 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 {
    int sum =0;
    public int sumOfLeftLeaves(TreeNode root) {

        int result =sum (root, false);
        return result;
    }

    public int sum (TreeNode n1, boolean isLeft){
        
        if(n1==null) 
            return 0;

        if(isLeft == true && n1.left == null && n1.right == null)
            sum += n1.val;
        
        sum(n1.left, true);
            
        sum(n1.right, false);
            
        return sum;
        
    }
}

Univalued Binary Tree:
https://leetcode.com/problems/univalued-binary-tree/description/

/**
 * 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 {
    boolean check = false;
    public boolean isUnivalTree(TreeNode root) {
        check (root, root.val);
        return check;
    }

    void check(TreeNode node, int temp){
        if(node == null)
            return;

            if(node.val == temp)
                check = true;
            else{
                check = false;
                return;
            }

        check(node.left, temp);
        if(check != false)
            check(node.right, temp);

    }
}

Maximum Depth of Binary Tree:
https://leetcode.com/problems/maximum-depth-of-binary-tree/description/

/**
 * 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 {
    int max = 0;
    public int maxDepth(TreeNode root) {

        maxiDepth(root, 1);

        return max;
        
    }

    public void maxiDepth(TreeNode node, int depth){
        if(node == null)
            return;
        System.out.println("Node = "+node.val+" Depth = "+depth);
        if (max<depth)
            max = depth;
        System.out.println(max);
    
        maxiDepth(node.left, depth+1);

        maxiDepth(node.right, depth+1);

    }
}

Minimum Depth of Binary Tree:
https://leetcode.com/problems/minimum-depth-of-binary-tree/description/

/**
 * 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 {
    int min = 0;
    public int minDepth(TreeNode root) {
        miniDepth(root, 1);
        return min;
    }

    void miniDepth(TreeNode node, int depth){
        if(node == null)
            return;
        
        if(node.left == null && node.right == null){
            if(min == 0)
                min = depth;
            else if(min>depth)
                min = depth;
            return;
        }
            miniDepth(node.left, depth+1);

            miniDepth(node.right, depth+1);
    }


}

Root Equals Sum of Children:
https://leetcode.com/problems/root-equals-sum-of-children/description/

/**
 * 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 {
    boolean check = false;
    int sum = 0;
    int count=0;
    
    public boolean checkTree(TreeNode root) {

        check(root, root.val);

        return check;
    }

    void check(TreeNode node, int rootValue){
        if( node == null)
            return;
        
        if(count!=0){
            sum+=node.val;
            
        }
        count++;

        check (node.left, rootValue);

        check (node.right, rootValue);

        if(sum==rootValue)
            check = true;
        else
            check = false;

    }
}

Tree Leetcode Solutions

Get Nivetharavi’s stories in your inbox

Written by Nivetharavi

No responses yet

More from Nivetharavi

Building Your First Spring App: A Step-by-Step Beginner’s Guide

Learn Spring with a Vehicle Shop example: IoC, Beans, Dependency Injection, XML configuration, and Autowiring.

Stack Data Structure & Problems

Learn Stack concepts and solve common DSA problems step by step using simple patterns, logic, and examples.

Tree Medium Level

Maximum Width of Binary Tree: https://leetcode.com/problems/maximum-width-of-binary-tree/description/

SLIDING WINDOW (FIXED SIZE)

Max Sum Subarray of size K: https://www.geeksforgeeks.org/problems/max-sum-subarray-of-size-k5313/1

Recommended from Medium

Stop Memorizing Big O Answers For Interviews: Learn to Think in Big O

Time and space complexity 101: work out the cost of any function you write, in any codebase.

Bank Customer Churn Analysis with Tableau

Which Customers are more likely to churn?

Ajax data analysis: Ideology and Pragmatism in 2021–2026

I made the grave mistake of watching pre-match coverage of the Dutch ESPN prior to the match FC Twente-Ajax (2–2). While the Eredivisie is…

Linear Regression: Understanding One of the Most Important Machine Learning Algorithms

Imagine you want to predict a person’s salary based on their years of experience.

The Most Dangerous Data Engineering Bug Isn’t a Failed Pipeline. It’s a Pipeline That Runs Twice.

How to build retry-safe, incremental data pipelines using Python and PostgreSQL — without duplicate records, corrupted metrics, or…

LC 560: Subarray Sum Equals K

Problem: Given an integer array nums (can contain negatives and zeros) and an integer k, count the contiguous subarrays whose sum equals k.

No responses yet

More from Nivetharavi

Building Your First Spring App: A Step-by-Step Beginner’s Guide

Learn Spring with a Vehicle Shop example: IoC, Beans, Dependency Injection, XML configuration, and Autowiring.

Stack Data Structure & Problems

Learn Stack concepts and solve common DSA problems step by step using simple patterns, logic, and examples.

Tree Medium Level

Maximum Width of Binary Tree: https://leetcode.com/problems/maximum-width-of-binary-tree/description/

SLIDING WINDOW (FIXED SIZE)

Max Sum Subarray of size K: https://www.geeksforgeeks.org/problems/max-sum-subarray-of-size-k5313/1

Recommended from Medium

Stop Memorizing Big O Answers For Interviews: Learn to Think in Big O

Time and space complexity 101: work out the cost of any function you write, in any codebase.

Bank Customer Churn Analysis with Tableau

Which Customers are more likely to churn?

Ajax data analysis: Ideology and Pragmatism in 2021–2026

I made the grave mistake of watching pre-match coverage of the Dutch ESPN prior to the match FC Twente-Ajax (2–2). While the Eredivisie is…

Linear Regression: Understanding One of the Most Important Machine Learning Algorithms

Imagine you want to predict a person’s salary based on their years of experience.

The Most Dangerous Data Engineering Bug Isn’t a Failed Pipeline. It’s a Pipeline That Runs Twice.

How to build retry-safe, incremental data pipelines using Python and PostgreSQL — without duplicate records, corrupted metrics, or…

LC 560: Subarray Sum Equals K

Problem: Given an integer array nums (can contain negatives and zeros) and an integer k, count the contiguous subarrays whose sum equals k.