Hello Trailblazers, in this post we're going to talk about the resolution of a very common error as given below:

First error: Exceeded max size limit of 12000000 OR First error: Exceeded max size limit of 6000000 

This error appears when you've exceeded the heap size limit in a single transaction. The heap size limit for a synchronous transaction is 6MB and for an asynchronous transaction is 12MB. Asynchronous transactions basically consists of batch classes, future methods and queueable apex.

How to resolve this error?

List<Account> accounts = [SELECT Id FROM Account];
// Stores 50,000 records at max - greater heap size

for(List<Account> accounts : [SELECT Id FROM Account]) {
}
// Stores 200 records at max - lesser heap size

4. Manage your code effectively using helper functions - Avoid class level variables.

void callMe()
{
    List<Account> accounts = [SELECT Id FROM Account];
    System.debug(Limits.getHeapSize()); // Coming as: 321085
}
callme();
System.debug(Limits.getHeapSize()); // Coming as: 1044

Hello Trailblazers,

In this post, we're going to learn about how we can use list data structure in apex. A list is a collection of elements or records that you want to store. List in apex can store elements of any data type. It can store: Integer, String, Boolean and any custom data type as well. For example: Account, Contact, Employee__c (Custom Object) etc.

Tutorial Video

The syntax to create a new list is as follows:

List<DataType> listName = new List<DataType>();

Here, DataType should be replaced by the type of data you would like to store and listName should be replaced by the name of the list. For example, if I want to create a list of integers, I can create it as follows:

List<Integer> numbers = new List<Integer>();

The above code snippet will create a list of Integers named as numbers. In this list you can store any number of integers. If you want to add elements to the list at the same moment when a list is initialized, you can do that as well. Consider the below examples:

1. Creating a list of Integers

Code Snippet:

List<Integer> numbers = new List<Integer>{1,2,3,4,5};
System.debug(numbers);

Output:

2. Creating a list of Strings

Code Snippet:

List<String> names = new List<String>{'Richard', 'Gilfoyle', 'Dinesh', 'Jared', 'Monica'};
System.debug(names);

Output:

In both the above examples, you can see that we've used curly braces {} to specify a comma separated set of values and that values are automatically added to the list. Using this way, you can initialize a list with a set of values. But what if you need to add some more data later on? Let's consider that now:

Adding elements to the list

List<Integer> numbers = new List<Integer>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
System.debug(numbers);

Accessing elements from the list

List<Integer> numbers = new List<Integer>{1,2,3,4,5};
System.debug(numbers);
System.debug('Element at index 3 = ' + numbers[3]);
System.debug('Element at index 3 using get() = ' + numbers.get(3));

Adding element at a particular index

If you want to add element at a particular index, you can use the add() method to do so. Just pass the index as the first parameter and the value as the second parameter to the add() method. For example:

Code Snippet:

List<Integer> numbers = new List<Integer>{1,2,3,4,5};
System.debug(numbers);
System.debug('Adding element "10" at index 3');
numbers.add(3, 10);
System.debug('Updated List = ' + numbers);

Output:

As you can see above, initially the list was: 1, 2, 3, 4, 5. The elements and their indexes for the list are shown below:

Then, we're going to add a new element with value 10 at index 3, so, the values 4 and 5 will be shifted ahead to index 4 and 5 respectively and the updated list will be:

Removing element from the list

We can remove an element from the list by using the remove() method. The remove() method accepts the index of the element that you want to remove. For example: If in the above list you want to remove element 10, then you can pass it's index i.e. 3 in the remove method as follows:

Code Snippet:

List<Integer> numbers = new List<Integer>{1,2,3,10,4,5};
System.debug(numbers);
System.debug('Removing element "10" from index 3');
numbers.remove(3);
System.debug('Updated List = ' + numbers);

Output:

These were the basic methods using which you can interact with the list data structure. There are some other methods as well. I am going to discuss those quickly below with a one line description and code snippets.

Other Commonly used List methods

clear() - Clear all elements in the list

Code Snippet:

List<Integer> numbers = new List<Integer>{1,2,3,4,5};
System.debug(numbers);
System.debug('Clearing list...');
numbers.clear();
System.debug('Updated list = ' + numbers);

Output:

As you can see above, we created a list of numbers, we used clear() method to clear the list. Then we displayed the list got a confirmation that it's empty.

isEmpty() - Returns true if the list is empty, otherwise returns false

Code Snippet:

List<Integer> numbers = new List<Integer>();
System.debug('List Empty --> ' + numbers.isEmpty());
System.debug('Adding "1" to the list');
numbers.add(1);
System.debug('List Empty --> ' + numbers.isEmpty());

Output:

As you can see above, initially, the list was empty, so the isEmpty() method is returning true when called on the numbers list. After that, we added "1" to the list and then the isEmpty() method is returning false.

size() - Returns the size of the list i.e. the total number of elements present in the list

Code Snippet:

List<Integer> numbers = new List<Integer>{1,2,3,4,5};
System.debug(numbers);
System.debug('Size of list = ' + numbers.size());

Output:

As you can see above, I have 5 elements in my list of numbers, so, the size of list is coming out to be 5.

contains() - Returns true if a particular element is present in the list, otherwise, returns false

Code Snippet:

List<Integer> numbers = new List<Integer>{1,2,3,4,5};
System.debug(numbers);
System.debug('3 is present in the list --> ' + numbers.contains(3));
System.debug('Removing 3 from index 2');
numbers.remove(2);
System.debug(numbers);
System.debug('3 is present in the list --> ' + numbers.contains(3));

Output:

As you can see above, we had 5 elements in the list initially: 1, 2, 3, 4, 5. We checked for element 3 using contains() and it returned true as 3 was present in the list. The element 3 was present at index 2 so, we removed 3 from the list by using remove() method and the updated list is: 1, 2, 4, 5. Finally, we checked for element 3 again if it's present in the list using contains() and this time, the result comes out to be false.

sort() - Sort the elements in the list in ascending order

Code Snippet:

List<Integer> numbers = new List<Integer>{1,4,5,3,2};
System.debug(numbers);
System.debug('Sorting list...');
numbers.sort();
System.debug(numbers);

Output:

As you can see above, initially, the list had elements: 1, 4, 5, 3, 2. Then we sorted the list using sort() and now, the list consist of elements in sorted order i.e.: 1, 2, 3, 4, 5.

These are the most common methods that are used while interacting with a list, although there are some other methods as well, I would suggest to have a look at the official salesforce documentation for more information.

That's all for this tutorial everyone, I hope you liked it. Let me know your feedback or if you have any queries in the comments down below. You can find the whole code snippet used in this tutorial here.

Happy Trailblazing..!!

Hello Trailblazers,

In the previous two posts, we learned about how can we implement a binary tree in apex and how we can insert a new node in a binary tree based on the value of it's parent node. You can have a look at them here:- Binary Tree implementation in Apex and Insertion in Binary Tree based on parent node | Custom comparator in Apex. Now, it's time to put our knowledge in action and solve a real problem. 

Tutorial Videos

Problem Statement: Find the Lead Manager

What is a Lead Manager?

How will you find the Lead Manager for two given employees?

public Id getLeadManager(Id firstEmployeeId, Id secondEmployeeId) {
    // * Add your code here
}

Solution: Find the Lead Manager

Step 1

Employee__c topEmployee = [SELECT Id FROM Employee__c WHERE Manager__c = null];

Map<Id, Employee__c> employeesMap = new Map<Id, Employee__c>([
    SELECT Id, (SELECT Id FROM Employees__r) FROM Employee__c
]);

Step 2

/*
*	Author:- Rahul Malhotra
*	Description:- Binary Tree implementation in apex
*	Created Date:- 13-07-2021
*	Last Modified:- 14-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public class BinaryTree {

    // * Node class
    public class Node {

        Object data;
        Node left;
        Node right;

        public Node(Object data) {
            this.data = data;
            this.left = NULL;
            this.right = NULL;
        }

        public Object getData() {
            return data;
        }
    }

    // * Root of binary tree
    Node root;

    // * Method to insert data in binary tree
    private void insertData(Object data) {

        // * If root is NULL, create a new node and return
        if(root==NULL) {
            root = new Node(data);
            return;
        }

        // * Initializing a queue of nodes
        List<Node> nodesQueue = new List<Node>();

        // * Adding root node to the queue
        nodesQueue.add(root);

        // * Looping while queue is not empty
        while(!nodesQueue.isEmpty()) {

            // * Getting the current node and removing it from the queue
            Node current = nodesQueue.get(0);
            nodesQueue.remove(0);

            // * If the left child of current node is not null, add it to the queue
            if(current.left!=NULL) {
                nodesQueue.add(current.left);
            }
            // * Otherwise, create a new node and attach it as the left child
            else {
                current.left = new Node(data);
                return;
            }

            // * If the right child of current node is not null, add it to the queue
            if(current.right!=NULL) {
                nodesQueue.add(current.right);
            }
            // * Otherwise, create a new node and attach it to the right child
            else {
                current.right = new Node(data);
                return;
            }
        }

    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to insert data inside a binary tree based on the parent node's data
    */
    public Node insertData(Object data, Object parentData, Comparator comparator) {

        // * If root node is NULL, create a new node, assign it as the root node and return that
        if(root==NULL) {
            root = new Node(data);
            return root;
        }

        // * Otherwise, call the recursive function using the root node
        return insertDataRecursive(root, data, parentData, comparator);
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This helper method is used to insert data inside a binary tree based on the parent node's data
    */
    private Node insertDataRecursive(Node current, Object data, Object parentData, Comparator comparator) {

        // * If current node's data is equal to parentData
        if(comparator.compare(current.data, parentData)) {

            // * If left child of current node is NULL, add a new node as the left child of the current node and return that
            if(current.left==NULL) {
                current.left = new Node(data);
                return current.left;
            } 
            
            // * Else if the right child of current node is NULL, add a new node as the right child of the current node and return that
            else if(current.right==NULL) {
                current.right = new Node(data);
                return current.right;
            } 
            
            // * Otherwise, return NULL as the current node already has two nodes and a new node cannot be inserted
            else {
                return NULL;
            }
        }

        // * If current node's data is not equal to parentData, check in the left and right subtrees

        // * If left subtree exists
        if(current.left!=NULL) {

            Node left = insertDataRecursive(current.left, data, parentData, comparator);

            // * If the node is inserted in the left subtree, return the value received from the left subtree
            if(left!=NULL) {
                return left;
            }
        }

        // * If right subtree exists
        if(current.right!=NULL) {

            Node right = insertDataRecursive(current.right, data, parentData, comparator);

            // * If the node is inserted in the right subtree, return the value received from the right subtree
            if(right!=NULL) {
                return right;
            }
        }

        // * Otherwise, return NULL as the node cannot be inserted
        return NULL;
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to create a binary tree
    */
    public void createBinaryTree(List<Object> elements) {

        // * Inserting elements in binary tree
        for(Object element : elements) {
            insertData(element);
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to print binary tree level by level
    */    
    public void levelOrderPrint() {

        // * Checking if root is not NULL
        if(root!=NULL) {

            String result = '\n';

            // * Initializing a queue
            List<Node> nodesQueue = new List<Node>();

            // * Adding root node to the queue
            nodesQueue.add(root);

            // * Looping while queue is not empty
            while(!nodesQueue.isEmpty()) {

                // * Getting nodes at current level
                Integer nodesAtCurrentLevel = nodesQueue.size();

                // * Looping while nodes at current level is more than 0
                while(nodesAtCurrentLevel>0) {

                    // * Getting the current node and removing it from the queue
                    Node current = nodesQueue.get(0);
                    nodesQueue.remove(0);

                    // * Adding current node data to the result
                    result += current.data + ' ';

                    // * If left child of the current node is not NULL, add it to the queue
                    if(current.left!=NULL) {
                        nodesQueue.add(current.left);
                    }

                    // * If right child of the current node is not NULL, add it to the queue
                    if(current.right!=NULL) {
                        nodesQueue.add(current.right);
                    }

                    // * Decrementing nodes at current level by 1
                    nodesAtCurrentLevel--;
                }

                // * Adding a new line to the result for next level
                result += '\n';
            }

            // * Displaying the result
            System.debug(result);
        } 

        // * If root is NULL, display error message
        else {
            System.debug('Tree not found');
        }
    }
}

/*
*  Author:- Rahul Malhotra
*  Description:- This method is used to find lowest common ancestor in a binary tree assuming that both object1 and object2 are present
*/    
public Node lowestCommonAncestor(Object object1, Object object2, Comparator comparator) {
    return lowestCommonAncestor(root, object1, object2, comparator);
}

How can we find the Lowest Common Ancestor in the Binary Tree?

/*
*  Author:- Rahul Malhotra
*  Description:- This helper method is used to find lowest common ancestor in a binary tree starting from a particular node
*/    
private Node lowestCommonAncestor(Node current, Object object1, Object object2, Comparator comparator) {        

    // * If the current node is NULL, return NULL
    if(current==NULL) {
        return NULL;
    }

    // * If current node's data is equal to one of object1 or object2, return the current node
    if(
        comparator.compare(current.data, object1) || 
        comparator.compare(current.data, object2)
    ) {
        return current;            
    }

    // * Otherwise, find object1 and object2 in left and right subtree
    Node left = lowestCommonAncestor(current.left, object1, object2, comparator);
    Node right = lowestCommonAncestor(current.right, object1, object2, comparator);

    /* 
    *   If one of object1 or object2 is present in the left subtree and one in right subtree, 
    *   return the current node as it's the lowest common ancestor
    */
    if(left!=NULL && right!=NULL) {
        return current;
    } 
    
    /* 
    *   Else if, both the object1 and object2 are present in the left subtree, 
    *   return the lowest common ancestor returned from the left subtree
    */
    else if(left!=NULL) {
        return left;
    }

    // * Else, return the lowest common ancestor returned from the right subtree
    return right;
}

So, in this method, we're first of all checking that if the current node is NULL, then we return NULL. This means that we've reached ahead of the leaf node and none of the object1 or object2 is present in the current branch of the binary tree. 

If that's not the case, we're comparing object1 with the current node's data (which is also of type object) and also the object2 with the current node's data. If the current node's data is equal to any of object1 or object2, we return the current node. The point to notice is that the current node can also be the lead manager node. Let's understand this with an example. 

Let's say, I need to find the lead manager of Richard and Erlich in the below binary tree:

Then definitely, Richard itself is the lead manager because he is managing Erlich and can approve any request Erlich may have with respect to him. So, at any point of time, if the current node's data is equal to any of object1 or object2, then the current node will be returned as the lowest common ancestor.

If that's not the case, then we're finding the lowest common ancestor in left and right subtree recursively. Note that we're passing current.left and current.right while calling the method recursively for left and right subtree.

Once we have a response from both the subtrees, we need to check that if both the left and right subtrees are returning us some value, it means that one of the employee id is present in the left subtree and one of the employee id is present in the right subtree, therefore, this comes under Scenario Number 3 as stated in the start of this section. So, we're going to return the current node as the lowest common ancestor.

Otherwise, if the left subtree is returning us some value, that means, both the object1 and object2 are present in the left subtree, and we've already got the lowest common ancestor of both the nodes so, we'll simply return the lowest common ancestor received from left subtree as it is.

Finally, if the right subtree is returning us some value, that means, both the object1 and object2 are present in the right subtree, and we've already got the lowest common ancestor of both the nodes so, we'll simply return the lowest common ancestor received from right subtree as it is.

Let's have a look at the updated BinaryTree class once:

/*
*	Author:- Rahul Malhotra
*	Description:- Binary Tree implementation in apex
*	Created Date:- 13-07-2021
*	Last Modified:- 14-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public class BinaryTree {

    // * Node class
    public class Node {

        Object data;
        Node left;
        Node right;

        public Node(Object data) {
            this.data = data;
            this.left = NULL;
            this.right = NULL;
        }

        public Object getData() {
            return data;
        }
    }

    // * Root of binary tree
    Node root;

    // * Method to insert data in binary tree
    private void insertData(Object data) {

        // * If root is NULL, create a new node and return
        if(root==NULL) {
            root = new Node(data);
            return;
        }

        // * Initializing a queue of nodes
        List<Node> nodesQueue = new List<Node>();

        // * Adding root node to the queue
        nodesQueue.add(root);

        // * Looping while queue is not empty
        while(!nodesQueue.isEmpty()) {

            // * Getting the current node and removing it from the queue
            Node current = nodesQueue.get(0);
            nodesQueue.remove(0);

            // * If the left child of current node is not null, add it to the queue
            if(current.left!=NULL) {
                nodesQueue.add(current.left);
            }
            // * Otherwise, create a new node and attach it as the left child
            else {
                current.left = new Node(data);
                return;
            }

            // * If the right child of current node is not null, add it to the queue
            if(current.right!=NULL) {
                nodesQueue.add(current.right);
            }
            // * Otherwise, create a new node and attach it to the right child
            else {
                current.right = new Node(data);
                return;
            }
        }

    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to insert data inside a binary tree based on the parent node's data
    */
    public Node insertData(Object data, Object parentData, Comparator comparator) {

        // * If root node is NULL, create a new node, assign it as the root node and return that
        if(root==NULL) {
            root = new Node(data);
            return root;
        }

        // * Otherwise, call the recursive function using the root node
        return insertDataRecursive(root, data, parentData, comparator);
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This helper method is used to insert data inside a binary tree based on the parent node's data
    */
    private Node insertDataRecursive(Node current, Object data, Object parentData, Comparator comparator) {

        // * If current node's data is equal to parentData
        if(comparator.compare(current.data, parentData)) {

            // * If left child of current node is NULL, add a new node as the left child of the current node and return that
            if(current.left==NULL) {
                current.left = new Node(data);
                return current.left;
            } 
            
            // * Else if the right child of current node is NULL, add a new node as the right child of the current node and return that
            else if(current.right==NULL) {
                current.right = new Node(data);
                return current.right;
            } 
            
            // * Otherwise, return NULL as the current node already has two nodes and a new node cannot be inserted
            else {
                return NULL;
            }
        }

        // * If current node's data is not equal to parentData, check in the left and right subtrees

        // * If left subtree exists
        if(current.left!=NULL) {

            Node left = insertDataRecursive(current.left, data, parentData, comparator);

            // * If the node is inserted in the left subtree, return the value received from the left subtree
            if(left!=NULL) {
                return left;
            }
        }

        // * If right subtree exists
        if(current.right!=NULL) {

            Node right = insertDataRecursive(current.right, data, parentData, comparator);

            // * If the node is inserted in the right subtree, return the value received from the right subtree
            if(right!=NULL) {
                return right;
            }
        }

        // * Otherwise, return NULL as the node cannot be inserted
        return NULL;
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to create a binary tree
    */
    public void createBinaryTree(List<Object> elements) {

        // * Inserting elements in binary tree
        for(Object element : elements) {
            insertData(element);
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to print binary tree level by level
    */    
    public void levelOrderPrint() {

        // * Checking if root is not NULL
        if(root!=NULL) {

            String result = '\n';

            // * Initializing a queue
            List<Node> nodesQueue = new List<Node>();

            // * Adding root node to the queue
            nodesQueue.add(root);

            // * Looping while queue is not empty
            while(!nodesQueue.isEmpty()) {

                // * Getting nodes at current level
                Integer nodesAtCurrentLevel = nodesQueue.size();

                // * Looping while nodes at current level is more than 0
                while(nodesAtCurrentLevel>0) {

                    // * Getting the current node and removing it from the queue
                    Node current = nodesQueue.get(0);
                    nodesQueue.remove(0);

                    // * Adding current node data to the result
                    result += current.data + ' ';

                    // * If left child of the current node is not NULL, add it to the queue
                    if(current.left!=NULL) {
                        nodesQueue.add(current.left);
                    }

                    // * If right child of the current node is not NULL, add it to the queue
                    if(current.right!=NULL) {
                        nodesQueue.add(current.right);
                    }

                    // * Decrementing nodes at current level by 1
                    nodesAtCurrentLevel--;
                }

                // * Adding a new line to the result for next level
                result += '\n';
            }

            // * Displaying the result
            System.debug(result);
        } 

        // * If root is NULL, display error message
        else {
            System.debug('Tree not found');
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to find lowest common ancestor in a binary tree assuming that both object1 and object2 are present
    */    
    public Node lowestCommonAncestor(Object object1, Object object2, Comparator comparator) {
        return lowestCommonAncestor(root, object1, object2, comparator);
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This helper method is used to find lowest common ancestor in a binary tree starting from a particular node
    */    
    private Node lowestCommonAncestor(Node current, Object object1, Object object2, Comparator comparator) {        

        // * If the current node is NULL, return NULL
        if(current==NULL) {
            return NULL;
        }

        // * If current node's data is equal to one of object1 or object2, return the current node
        if(
            comparator.compare(current.data, object1) || 
            comparator.compare(current.data, object2)
        ) {
            return current;            
        }

        // * Otherwise, find object1 and object2 in left and right subtree
        Node left = lowestCommonAncestor(current.left, object1, object2, comparator);
        Node right = lowestCommonAncestor(current.right, object1, object2, comparator);

        /* 
        *   If one of object1 or object2 is present in the left subtree and one in right subtree, 
        *   return the current node as it's the lowest common ancestor
        */
        if(left!=NULL && right!=NULL) {
            return current;
        } 
        
        /* 
        *   Else if, both the object1 and object2 are present in the left subtree, 
        *   return the lowest common ancestor returned from the left subtree
        */
        else if(left!=NULL) {
            return left;
        }

        // * Else, return the lowest common ancestor returned from the right subtree
        return right;
    }
}

Now, our lowestCommonAncestor method is complete. Let's have a look at the comparator class as well:

public abstract class Comparator {
    public abstract Boolean compare(Object o1, Object o2);
}

As you can see above, Comparator is an abstract class which is having a single method that's going to receive two objects and return a Boolean true if both the objects are equal and false if both the objects are not equal. We have created this abstract class to keep our binary tree code independent of data types as we can implement a child of this abstract class and do the comparison there. For example: In our case, we need to compare employee ids, so, we can create another class as shown below:

/* 
*   Author:- Rahul Malhotra
*   Description:- This helper class is used to compare two Ids.
*   It's used to find the lowest common ancestor of binary tree
*/
public class IdCompare extends Comparator {
    public override Boolean compare(Object o1, Object o2) {
        return (Id) o1 == (Id) o2;
    }
}

This IdCompare class is extending our abstract Comparator class and is implementing the compare method. For our binary tree, we're checking if both the objects (when typecasted to ids) are equal or not. If both the ids are equal, the method will return true, otherwise, it'll return false.

Now, whenever we need to find the lowest common ancestor or the lead manager id after constructing the binary tree, we can simply call the method as shown below:

BinaryTree.Node lowestCommonAncestorNode = tree.lowestCommonAncestor(firstEmployeeId, secondEmployeeId, new IdCompare());

I have created an EmployeeHelper class which is having all the code and methods to receive the two employee ids and find out the lead manager id. Let's quickly have a look at the class as a whole once:

/*
*	Author:- Rahul Malhotra
*	Description:- Helper class for Employee related computations
*	Created Date:- 14-07-2021
*	Last Modified:- 14-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public with sharing class EmployeeHelper {

    /* 
    *   Author:- Rahul Malhotra
    *   Description:- This helper class is used to compare two Ids.
    *   It's used to find the lowest common ancestor of binary tree
    */
    public class IdCompare extends Comparator {
        public override Boolean compare(Object o1, Object o2) {
            return (Id) o1 == (Id) o2;
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This helper method is used to get the Lead Manager of two employees given the employee id of both the employees
    */    
    public Id getLeadManager(Id firstEmployeeId, Id secondEmployeeId) {

        // * Defining lead manager id and initializing a binary tree
        Id leadManagerId;
        BinaryTree tree = new BinaryTree();

        // * Finding the topmost employee of the hierarchy
        Employee__c topEmployee = [SELECT Id FROM Employee__c WHERE Manager__c = null];

        // * Proceed ahead if top employee is not NULL
        if(topEmployee!=NULL) {

            // * Storing the top employee id
            Id topEmployeeId = topEmployee.Id;

            // * Storing all the employees along with the child employees in the employees map
            Map<Id, Employee__c> employeesMap = new Map<Id, Employee__c>([SELECT Id, (SELECT Id FROM Employees__r) FROM Employee__c]);

            /* 
            *   Initializing a set of ids to store the tree elements, 
            *   a queue of ids as idQueue and creating an instance of IdCompare class
            */
            Set<Id> treeElements = new Set<Id>();
            List<Id> idQueue = new List<Id>();
            IdCompare idCompare = new IdCompare();

            // * Adding the top employee id to the idQueue
            idQueue.add(topEmployeeId);

            // * Inserting topEmployeeId in the tree
            tree.insertData(topEmployeeId, NULL, idCompare);

            // * Looping while idQueue is not empty
            while(!idQueue.isEmpty()) {

                // * Getting the id of employee in the front of queue
                Id currentEmployeeId = idQueue.get(0);
                idQueue.remove(0);

                // * Used to prevent duplicacy in tree
                if(!treeElements.contains(currentEmployeeId)) {

                    // * Adding current employee id to tree elements
                    treeElements.add(currentEmployeeId);

                    // * If the current employee record has child records
                    if(employeesMap.containsKey(currentEmployeeId)) {

                        // * Getting the child records and inserting them in the tree
                        List<Employee__c> childEmployees = employeesMap.get(currentEmployeeId).Employees__r;
                        if(childEmployees!=NULL && !childEmployees.isEmpty()) {
                            for(Employee__c childEmployee : childEmployees) {
                                idQueue.add(childEmployee.Id);
                                tree.insertData(childEmployee.Id, currentEmployeeId, idCompare);
                            }
                        }
                    }
                }
            }

            // * Finding the lead manager in the binary tree using the first employee id and second employee id
            BinaryTree.Node lowestCommonAncestorNode = tree.lowestCommonAncestor(firstEmployeeId, secondEmployeeId, new IdCompare());

            if(lowestCommonAncestorNode!=NULL) {
                // * Storing the lead manager id
                leadManagerId = (Id) lowestCommonAncestorNode.getData();
            }
        }

        // * Returning the lead manager id
        return leadManagerId;
    }
}

First of all, we have the IdCompare class which we've already seen, the second method is getLeadManager() method which is receiving two employee ids and returning the leadManagerId. Inside this method, we defined a variable leadManagerId which will store the lead manager id and then we initialized our binary tree by creating an instance of BinaryTree class.

After that we queried the topmost employee of the hierarchy as we've already discussed that it won't be having any manager. If we found the topmost employee, we're storing it's id in topEmployeeId variable and we're quering all other employees (managers) along with their team mates.

If you remember from the previous tutorial, we have overridden our insertData() method in the BinaryTree class and in the new method we're receiving the current data and the parent node's data to insert a new node in the binary tree. We're going to use the same method to fill up our binary tree here as we're querying all employees along with their managers, so we'll first add the manager id to the binary tree and then the id of employees reporting to the current manager.

For this purpose, I have created a queue named as idQueue which is storing the topEmployeeId i.e. the root node id. Then we're inserting this topEmployeeId in the tree. After that, we're having a loop which will continue while idQueue has some elements. In each iteration of the loop, we're getting the current employee id from the front of the queue and then, we're getting all the employees that are reporting to the current employee. We're then inserting those employees in the idQueue as well as in the tree. In this way, we've all the employee ids inserted into the binary tree. We're also using treeElements set just to make sure that we're not processing an employee id more than once.

Once the binary tree is ready, we're finding out the lowest common ancestor (lead manager) node using the lowestCommonAncestor() method. If we found that node, we're populating the leadManagerId with the value of that node i.e. the employee id. Finally, we're returning the leadManagerId from our method and we're done.

Congratulations!! You've just solved a real world problem using a binary tree. Now, the fun part, it's time for testing..!!

For testing, I have created a large employee hierarchy in my Salesforce org as shown below:

Now, we'll check for Angela and Milana by passing on their employee ids and we'll verify if the lead manager for these two employees is Monica or not.

Let's see the employee records in Salesforce as well:

We're going to run the below code snippet, which is querying records of Angela and Milana and then passing their employee ids in order to find the lead manager id. Once we have the lead manager id, we're querying the lead manager employee record and displaying it's name.

Employee__c angela = [SELECT Id FROM Employee__c WHERE Name =: 'E030'];
Employee__c milana = [SELECT Id FROM Employee__c WHERE Name =: 'E026'];
EmployeeHelper employeeHelper = new EmployeeHelper();
Id leadManagerId = employeeHelper.getLeadManager(angela.Id, milana.Id);
Employee__c employee = [SELECT Name__c FROM Employee__c WHERE Id =: leadManagerId];
System.debug(employee.Name__c);

Let's have a look at the output now:

As you can see in the image above, in the 3rd last line, we're getting the name Monica in the debug, that means we're getting Monica as our Lead Manager for Angela and Milana. So, our code is working perfectly fine.

That's all for this tutorial everyone, I hope you liked it. You can find the full code for this tutorial in the apex-data-structures github repository here.

There can be many other approaches to code this, for example: you can use an interface instead of an abstract class to implement the comparator or you can add conditional logic to find the data type of object and then compare the elements accordingly. I would love to see what solution you come up with. Let me know your thoughts in the comments down below.

Happy Trailblazing..!!

Hello Trailblazers,

In this tutorial we're going to see how we can insert a new node in binary tree recursively based on the parent node. We're going to refer the code we created in our previous tutorial and add a new insertData() method which is going to accept the new data, the parent data and a comparator class. Then it's going to compare if the parent data is equal to the data of any node in the binary tree or not, in case we find such a node, we're going to consider that node as our parent node and we'll link the new node as a child of the parent node. If not, we'll return NULL which means the node cannot be inserted in our binary tree.

Tutorial Video

Existing Binary Tree Code

/*
*	Author:- Rahul Malhotra
*	Description:- Binary Tree implementation in apex
*	Created Date:- 13-07-2021
*	Last Modified:- 13-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public class BinaryTree {

    // * Node class
    public class Node {

        Object data;
        Node left;
        Node right;

        public Node(Object data) {
            this.data = data;
            this.left = NULL;
            this.right = NULL;
        }

    }

    // * Root of binary tree
    Node root;

    // * Method to insert data in binary tree
    private void insertData(Object data) {

        // * If root is NULL, create a new node and return
        if(root==NULL) {
            root = new Node(data);
            return;
        }

        // * Initializing a queue of nodes
        List<Node> nodesQueue = new List<Node>();

        // * Adding root node to the queue
        nodesQueue.add(root);

        // * Looping while queue is not empty
        while(!nodesQueue.isEmpty()) {

            // * Getting the current node and removing it from the queue
            Node current = nodesQueue.get(0);
            nodesQueue.remove(0);

            // * If the left child of current node is not null, add it to the queue
            if(current.left!=NULL) {
                nodesQueue.add(current.left);
            }
            // * Otherwise, create a new node and attach it as the left child
            else {
                current.left = new Node(data);
                return;
            }

            // * If the right child of current node is not null, add it to the queue
            if(current.right!=NULL) {
                nodesQueue.add(current.right);
            }
            // * Otherwise, create a new node and attach it to the right child
            else {
                current.right = new Node(data);
                return;
            }
        }

    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to create a binary tree
    */
    public void createBinaryTree(List<Object> elements) {

        // * Inserting elements in binary tree
        for(Object element : elements) {
            insertData(element);
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to print binary tree level by level
    */    
    public void levelOrderPrint() {

        // * Checking if root is not NULL
        if(root!=NULL) {

            String result = '\n';

            // * Initializing a queue
            List<Node> nodesQueue = new List<Node>();

            // * Adding root node to the queue
            nodesQueue.add(root);

            // * Looping while queue is not empty
            while(!nodesQueue.isEmpty()) {

                // * Getting nodes at current level
                Integer nodesAtCurrentLevel = nodesQueue.size();

                // * Looping while nodes at current level is more than 0
                while(nodesAtCurrentLevel>0) {

                    // * Getting the current node and removing it from the queue
                    Node current = nodesQueue.get(0);
                    nodesQueue.remove(0);

                    // * Adding current node data to the result
                    result += current.data + ' ';

                    // * If left child of the current node is not NULL, add it to the queue
                    if(current.left!=NULL) {
                        nodesQueue.add(current.left);
                    }

                    // * If right child of the current node is not NULL, add it to the queue
                    if(current.right!=NULL) {
                        nodesQueue.add(current.right);
                    }

                    // * Decrementing nodes at current level by 1
                    nodesAtCurrentLevel--;
                }

                // * Adding a new line to the result for next level
                result += '\n';
            }

            // * Displaying the result
            System.debug(result);
        } 

        // * If root is NULL, display error message
        else {
            System.debug('Tree not found');
        }
    }
}

/*
*  Author:- Rahul Malhotra
*  Description:- This method is used to insert data inside a binary tree based on the parent node's data
*/
public Node insertData(Object data, Object parentData, Comparator comparator) {

    // * If root node is NULL, create a new node, assign it as the root node and return that
    if(root==NULL) {
        root = new Node(data);
        return root;
    }

    // * Otherwise, call the recursive function using the root node
    return insertDataRecursive(root, data, parentData, comparator);
}

/*
*  Author:- Rahul Malhotra
*  Description:- This helper method is used to insert data inside a binary tree based on the parent node's data
*/
private Node insertDataRecursive(Node current, Object data, Object parentData, Comparator comparator) {

    // * If current node's data is equal to parentData
    if(comparator.compare(current.data, parentData)) {

        // * If left child of current node is NULL, add a new node as the left child of the current node and return that
        if(current.left==NULL) {
            current.left = new Node(data);
            return current.left;
        } 
        
        // * Else if the right child of current node is NULL, add a new node as the right child of the current node and return that
        else if(current.right==NULL) {
            current.right = new Node(data);
            return current.right;
        } 
        
        // * Otherwise, return NULL as the current node already has two nodes and a new node cannot be inserted
        else {
            return NULL;
        }
    }

    // * If current node's data is not equal to parentData, check in the left and right subtrees

    // * If left subtree exists
    if(current.left!=NULL) {

        Node left = insertDataRecursive(current.left, data, parentData, comparator);

        // * If the node is inserted in the left subtree, return the value received from the left subtree
        if(left!=NULL) {
            return left;
        }
    }

    // * If right subtree exists
    if(current.right!=NULL) {

        Node right = insertDataRecursive(current.right, data, parentData, comparator);

        // * If the node is inserted in the right subtree, return the value received from the right subtree
        if(right!=NULL) {
            return right;
        }
    }

    // * Otherwise, return NULL as the node cannot be inserted
    return NULL;
}

/*
*	Author:- Rahul Malhotra
*	Description:- Binary Tree implementation in apex
*	Created Date:- 13-07-2021
*	Last Modified:- 14-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public class BinaryTree {

    // * Node class
    public class Node {

        Object data;
        Node left;
        Node right;

        public Node(Object data) {
            this.data = data;
            this.left = NULL;
            this.right = NULL;
        }

        public Object getData() {
            return data;
        }
    }

    // * Root of binary tree
    Node root;

    // * Method to insert data in binary tree
    private void insertData(Object data) {

        // * If root is NULL, create a new node and return
        if(root==NULL) {
            root = new Node(data);
            return;
        }

        // * Initializing a queue of nodes
        List<Node> nodesQueue = new List<Node>();

        // * Adding root node to the queue
        nodesQueue.add(root);

        // * Looping while queue is not empty
        while(!nodesQueue.isEmpty()) {

            // * Getting the current node and removing it from the queue
            Node current = nodesQueue.get(0);
            nodesQueue.remove(0);

            // * If the left child of current node is not null, add it to the queue
            if(current.left!=NULL) {
                nodesQueue.add(current.left);
            }
            // * Otherwise, create a new node and attach it as the left child
            else {
                current.left = new Node(data);
                return;
            }

            // * If the right child of current node is not null, add it to the queue
            if(current.right!=NULL) {
                nodesQueue.add(current.right);
            }
            // * Otherwise, create a new node and attach it to the right child
            else {
                current.right = new Node(data);
                return;
            }
        }

    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to insert data inside a binary tree based on the parent node's data
    */
    public Node insertData(Object data, Object parentData, Comparator comparator) {

        // * If root node is NULL, create a new node, assign it as the root node and return that
        if(root==NULL) {
            root = new Node(data);
            return root;
        }

        // * Otherwise, call the recursive function using the root node
        return insertDataRecursive(root, data, parentData, comparator);
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This helper method is used to insert data inside a binary tree based on the parent node's data
    */
    private Node insertDataRecursive(Node current, Object data, Object parentData, Comparator comparator) {

        // * If current node's data is equal to parentData
        if(comparator.compare(current.data, parentData)) {

            // * If left child of current node is NULL, add a new node as the left child of the current node and return that
            if(current.left==NULL) {
                current.left = new Node(data);
                return current.left;
            } 
            
            // * Else if the right child of current node is NULL, add a new node as the right child of the current node and return that
            else if(current.right==NULL) {
                current.right = new Node(data);
                return current.right;
            } 
            
            // * Otherwise, return NULL as the current node already has two nodes and a new node cannot be inserted
            else {
                return NULL;
            }
        }

        // * If current node's data is not equal to parentData, check in the left and right subtrees

        // * If left subtree exists
        if(current.left!=NULL) {

            Node left = insertDataRecursive(current.left, data, parentData, comparator);

            // * If the node is inserted in the left subtree, return the value received from the left subtree
            if(left!=NULL) {
                return left;
            }
        }

        // * If right subtree exists
        if(current.right!=NULL) {

            Node right = insertDataRecursive(current.right, data, parentData, comparator);

            // * If the node is inserted in the right subtree, return the value received from the right subtree
            if(right!=NULL) {
                return right;
            }
        }

        // * Otherwise, return NULL as the node cannot be inserted
        return NULL;
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to create a binary tree
    */
    public void createBinaryTree(List<Object> elements) {

        // * Inserting elements in binary tree
        for(Object element : elements) {
            insertData(element);
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to print binary tree level by level
    */    
    public void levelOrderPrint() {

        // * Checking if root is not NULL
        if(root!=NULL) {

            String result = '\n';

            // * Initializing a queue
            List<Node> nodesQueue = new List<Node>();

            // * Adding root node to the queue
            nodesQueue.add(root);

            // * Looping while queue is not empty
            while(!nodesQueue.isEmpty()) {

                // * Getting nodes at current level
                Integer nodesAtCurrentLevel = nodesQueue.size();

                // * Looping while nodes at current level is more than 0
                while(nodesAtCurrentLevel>0) {

                    // * Getting the current node and removing it from the queue
                    Node current = nodesQueue.get(0);
                    nodesQueue.remove(0);

                    // * Adding current node data to the result
                    result += current.data + ' ';

                    // * If left child of the current node is not NULL, add it to the queue
                    if(current.left!=NULL) {
                        nodesQueue.add(current.left);
                    }

                    // * If right child of the current node is not NULL, add it to the queue
                    if(current.right!=NULL) {
                        nodesQueue.add(current.right);
                    }

                    // * Decrementing nodes at current level by 1
                    nodesAtCurrentLevel--;
                }

                // * Adding a new line to the result for next level
                result += '\n';
            }

            // * Displaying the result
            System.debug(result);
        } 

        // * If root is NULL, display error message
        else {
            System.debug('Tree not found');
        }
    }
}

/*
*	Author:- Rahul Malhotra
*	Description:- Comparator class to be used in Binary Tree
*	Created Date:- 14-07-2021
*	Last Modified:- 14-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public abstract class Comparator {
    public abstract Boolean compare(Object o1, Object o2);
}

/* 
*   Author:- Rahul Malhotra
*   Description:- This helper class is used to compare two integers.
*   It's used in the creation of binary tree
*/
public class IntegerCompare extends Comparator {
    public override Boolean compare(Object o1, Object o2) {
        return (Integer) o1 == (Integer) o2;
    }
}

IntegerCompare integerCompare = new IntegerCompare();
BinaryTree tree = new BinaryTree();
tree.insertData(1, null, integerCompare);
tree.insertData(2, 1, integerCompare);
tree.insertData(3, 1, integerCompare);
tree.insertData(7, 3, integerCompare);
tree.insertData(4, 2, integerCompare);
tree.levelOrderPrint();

Hello Trailblazers,

In this post we're going to talk about how we can create a Binary Tree in Apex. Let's see how a Binary Tree looks like:

As you can see above, we have a root node which is 1 in the above image, and each node in the tree can have two children at max. In the above tree, the nodes: 4 5 6 and 7 are called leaf nodes as they have no children.

Tutorial Video

Let's have a quick look at the full code once, then we'll discuss everything in detail.

/*
*	Author:- Rahul Malhotra
*	Description:- Binary Tree implementation in apex
*	Created Date:- 13-07-2021
*	Last Modified:- 13-07-2021
*       Code Origin:- SFDC Stop (https://www.sfdcstop.com)
*/
public class BinaryTree {

    // * Node class
    public class Node {

        Object data;
        Node left;
        Node right;

        public Node(Object data) {
            this.data = data;
            this.left = NULL;
            this.right = NULL;
        }

    }

    // * Root of binary tree
    Node root;

    // * Method to insert data in binary tree
    private void insertData(Object data) {

        // * If root is NULL, create a new node and return
        if(root==NULL) {
            root = new Node(data);
            return;
        }

        // * Initializing a queue of nodes
        List<Node> nodesQueue = new List<Node>();

        // * Adding root node to the queue
        nodesQueue.add(root);

        // * Looping while queue is not empty
        while(!nodesQueue.isEmpty()) {

            // * Getting the current node and removing it from the queue
            Node current = nodesQueue.get(0);
            nodesQueue.remove(0);

            // * If the left child of current node is not null, add it to the queue
            if(current.left!=NULL) {
                nodesQueue.add(current.left);
            }
            // * Otherwise, create a new node and attach it as the left child
            else {
                current.left = new Node(data);
                return;
            }

            // * If the right child of current node is not null, add it to the queue
            if(current.right!=NULL) {
                nodesQueue.add(current.right);
            }
            // * Otherwise, create a new node and attach it to the right child
            else {
                current.right = new Node(data);
                return;
            }
        }

    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to create a binary tree
    */
    public void createBinaryTree(List<Object> elements) {

        // * Inserting elements in binary tree
        for(Object element : elements) {
            insertData(element);
        }
    }

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to print binary tree level by level
    */    
    public void levelOrderPrint() {

        // * Checking if root is not NULL
        if(root!=NULL) {

            String result = '\n';

            // * Initializing a queue
            List<Node> nodesQueue = new List<Node>();

            // * Adding root node to the queue
            nodesQueue.add(root);

            // * Looping while queue is not empty
            while(!nodesQueue.isEmpty()) {

                // * Getting nodes at current level
                Integer nodesAtCurrentLevel = nodesQueue.size();

                // * Looping while nodes at current level is more than 0
                while(nodesAtCurrentLevel>0) {

                    // * Getting the current node and removing it from the queue
                    Node current = nodesQueue.get(0);
                    nodesQueue.remove(0);

                    // * Adding current node data to the result
                    result += current.data + ' ';

                    // * If left child of the current node is not NULL, add it to the queue
                    if(current.left!=NULL) {
                        nodesQueue.add(current.left);
                    }

                    // * If right child of the current node is not NULL, add it to the queue
                    if(current.right!=NULL) {
                        nodesQueue.add(current.right);
                    }

                    // * Decrementing nodes at current level by 1
                    nodesAtCurrentLevel--;
                }

                // * Adding a new line to the result for next level
                result += '\n';
            }

            // * Displaying the result
            System.debug(result);
        } 

        // * If root is NULL, display error message
        else {
            System.debug('Tree not found');
        }
    }
}

Creating Node class

    // * Node class
    public class Node {

        Object data;
        Node left;
        Node right;

        public Node(Object data) {
            this.data = data;
            this.left = NULL;
            this.right = NULL;
        }

    }

Insertion in Binary Tree

    // * Root of binary tree
    Node root;

    // * Method to insert data in binary tree
    private void insertData(Object data) {

        // * If root is NULL, create a new node and return
        if(root==NULL) {
            root = new Node(data);
            return;
        }

        // * Initializing a queue of nodes
        List<Node> nodesQueue = new List<Node>();

        // * Adding root node to the queue
        nodesQueue.add(root);

        // * Looping while queue is not empty
        while(!nodesQueue.isEmpty()) {

            // * Getting the current node and removing it from the queue
            Node current = nodesQueue.get(0);
            nodesQueue.remove(0);

            // * If the left child of current node is not null, add it to the queue
            if(current.left!=NULL) {
                nodesQueue.add(current.left);
            }
            // * Otherwise, create a new node and attach it as the left child
            else {
                current.left = new Node(data);
                return;
            }

            // * If the right child of current node is not null, add it to the queue
            if(current.right!=NULL) {
                nodesQueue.add(current.right);
            }
            // * Otherwise, create a new node and attach it to the right child
            else {
                current.right = new Node(data);
                return;
            }
        }

    }

Level Order Print of Binary Tree

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to print binary tree level by level
    */    
    public void levelOrderPrint() {

        // * Checking if root is not NULL
        if(root!=NULL) {

            String result = '\n';

            // * Initializing a queue
            List<Node> nodesQueue = new List<Node>();

            // * Adding root node to the queue
            nodesQueue.add(root);

            // * Looping while queue is not empty
            while(!nodesQueue.isEmpty()) {

                // * Getting nodes at current level
                Integer nodesAtCurrentLevel = nodesQueue.size();

                // * Looping while nodes at current level is more than 0
                while(nodesAtCurrentLevel>0) {

                    // * Getting the current node and removing it from the queue
                    Node current = nodesQueue.get(0);
                    nodesQueue.remove(0);

                    // * Adding current node data to the result
                    result += current.data + ' ';

                    // * If left child of the current node is not NULL, add it to the queue
                    if(current.left!=NULL) {
                        nodesQueue.add(current.left);
                    }

                    // * If right child of the current node is not NULL, add it to the queue
                    if(current.right!=NULL) {
                        nodesQueue.add(current.right);
                    }

                    // * Decrementing nodes at current level by 1
                    nodesAtCurrentLevel--;
                }

                // * Adding a new line to the result for next level
                result += '\n';
            }

            // * Displaying the result
            System.debug(result);
        } 

        // * If root is NULL, display error message
        else {
            System.debug('Tree not found');
        }
    }

Creating Binary Tree from a list of elements

    /*
    *  Author:- Rahul Malhotra
    *  Description:- This method is used to create a binary tree
    */
    public void createBinaryTree(List<object> elements) {

        // * Inserting elements in binary tree
        for(Object element : elements) {
            insertData(element);
        }
    }

Code Execution and Output

BinaryTree tree = new BinaryTree();
tree.createBinaryTree(new List<Integer>{1,2,3,4,5,6,7});
tree.levelOrderPrint();

BinaryTree tree = new BinaryTree();
tree.createBinaryTree(new List<String>{'A','B','C','D','E','F','G'});
tree.levelOrderPrint();

As you can see above, this time we are passing a list of strings instead of integers, let's see the output when the above code is executed:

As you can see above, this time also, we're getting the correct output as the tree is created successfully. This means that our code is generic and can be used with different data types.

So, that's all for this tutorial everyone, I hope you learned something new. Try to implement this by your own and let me know if you have any questions in the comments down below. You can find the full code for this tutorial in the apex-data-structures github repository here.

Happy Trailblazing..!!