Boundary Root to Leaf Path traversal of a Binary Tree

<script>

    // JavaScript implementation to print the 
    // path in Boundary Root to Leaf 
    // Path Traversal.
    
    let row;
    let count = 0;

    // Structure of tree node
    class Node
    {
        constructor(key) {
           this.left = null;
           this.right = null;
           this.key = key;
        }
    }

    // Utility function to
    // create a new node
    function newNode(key)
    {
        let temp = new Node(key);
        return (temp);
    }

    // Function to calculate the length
    // of longest path of the tree
    function lengthOfLongestPath(node)
    {

        // Base Case
        if (node == null)
            return 0;

        // Recursive call to calculate the
        // length of longest path
        let left = lengthOfLongestPath(node.left);
        let right = lengthOfLongestPath(node.right);

        return 1 + (left > right ? left : right);
    }

    // Function to copy the complete
    // path in a matrix
    function copyPath(path, index, mtrx, r)
    {

        // Loop to copy the path
        for(let i = 0; i < index; i++)
        {
            mtrx[r][i] = path[i];
        }
    }

    // Function to store all path
    // one by one in matrix
    function storePath(node, path, index, mtrx)
    {

        // Base condition
        if (node == null)
        {
            return;
        }

        // Inserting the current node
        // into the current path
        path[index] = node.key;

        // Recursive call for
        // the left sub tree
        storePath(node.left, path,
                  index + 1, mtrx);

        // Recursive call for
        // the right sub tree
        storePath(node.right, path,
                  index + 1, mtrx);

        // Condition to check that current
        // node is a leaf node or not
        if (node.left == null &&
            node.right == null)
        {

            // Incrementation for changing
            // row
            row = row + 1;

            // Function call for copying
            // the path
            copyPath(path, index + 1, mtrx, row);
        }
    }

    // Function to calculate
    // total path
    function totalPath(node)
    {
        if (node == null)
        {
            return count;
        }
        if (node.left == null &&
            node.right == null)
        {
            return count + 1;
        }
        count = totalPath(node.left);
        return totalPath(node.right);
    }

    // Function for Clockwise Spiral Traversal
    // of Binary Tree
    function traverse_matrix(mtrx, height, width)
    {
        let j = 0, k1 = 0, k2 = 0;
        let k3 = height - 1;
        let k4 = width - 1;

        for(let round = 0; round < parseInt(height / 2, 10); 
        round++)
        {
            for(j = k2; j < width; j++)
            {

                // Only print those values which
                // are not MAX_INTEGER
                if (mtrx[k1][j] != Number.MAX_VALUE)
                {
                    document.write(mtrx[k1][j] + " ");
                }
            }
            document.write("</br>");

            k2 = 0;
            k1++;

            for(j = k4; j >= 0; j--)
            {

                // Only print those values which
                // are not MAX_INTEGER
                if (mtrx[k3][j] != Number.MAX_VALUE)
                {
                    document.write(mtrx[k3][j] + " ");
                }
            }
            document.write("</br>");

            k4 = width - 1;
            k3--;
        }

        // Condition (one row may be left
        // traversing)
        // If number of rows in matrix are odd
        if (height % 2 != 0)
        {
            for(j = k2; j < width; j++)
            {

                // Only print those values which are
                // not MAX_INTEGER
                if (mtrx[k1][j] != Number.MAX_VALUE)
                {
                    document.write(mtrx[k1][j] + " ");
                }
            }
        }
    }

    // Function to print all the paths
    // in Boundary Root to Leaf
    // Path Traversal
    function PrintPath(node)
    {

        // Calculate the length of
        // longest path of the tree
        let max_len = lengthOfLongestPath(node);

        // Calculate total path
        let total_path = totalPath(node);

        // Array to store path
        let path = new Array(max_len);
        path.fill(0);

        // Use double pointer to create
        // 2D array which will contain
        // all path of the tree
        let mtrx = new Array(total_path);

        // Initialize complete matrix with
        // MAX INTEGER(purpose garbage)
        for(let i = 0; i < total_path; i++)
        {
            mtrx[i] = new Array(max_len);
            for(let j = 0; j < max_len; j++)
            {
                mtrx[i][j] = Number.MAX_VALUE;
            }
        }

        row = -1;
        storePath(node, path, 0, mtrx);

        // Print the circular clockwise spiral
        // traversal of the tree
        traverse_matrix(mtrx, total_path, max_len);
    }
    
    /* 10
      /  \
     13  11
        /  \
       19   23
      / \   / \
     21 29 43  15
              /
             7 */
              
    // Create Binary Tree as shown
    let root = newNode(10);
    root.left = newNode(13);
    root.right = newNode(11);
 
    root.right.left = newNode(19);
    root.right.right = newNode(23);
 
    root.right.left.left = newNode(21);
    root.right.left.right = newNode(29);
    root.right.right.left = newNode(43);
    root.right.right.right = newNode(15);
    root.right.right.right.left = newNode(7);
 
    // Function Call
    PrintPath(root);

</script>