Is there any difference between these two functions 
private Customer splay(Customer m_root, int ID){
        //Base case
        //Node is null or at the root already
        if(m_root == null || m_root.m_id == ID){
            return m_root;
        }
        //This case, ID goes to the left hand side
        if(ID < m_root.getID()){
            //if there is no left child
            if(m_root.m_left == null){
                return m_root;
            }
            //if ID is lesser, Zig-Zig (left-left)
            if(ID < m_root.m_left.getID()){
                //m_root.m_left.m_left = splay(m_root.m_left.m_left,ID);
                m_root.setLeft(splay(m_root.getLeft().getLeft(), ID));
                m_root = rightRotate(m_root);
            } 
            //Zig-Zag(left-right)
            else if(ID > m_root.m_left.getID()){
                //m_root.m_left.m_right = splay(m_root.m_left.m_right, ID);
                m_root.setLeft(splay(m_root.getLeft().getLeft(), ID));
                if(m_root.m_left.m_right != null){
                    m_root.m_left = leftRotate(m_root.m_left);
                }
            }
            //Final rotation to splay node to the root
            if(m_root.m_left == null){
                return m_root;
            } else {
                return rightRotate(m_root);
            }
        } else { //This case, ID goes to the right hand side
            //if there is no right child
            if(m_root.m_right == null){
                return m_root;
            }
            //if ID is lesser, Zag-Zag(right-right)
            if(ID > m_root.m_right.getID()){
                m_root.setRight(splay(m_root.getRight().getRight(), ID));
                m_root = leftRotate(m_root);
            }
            //Zag-Zig(right-left)
            else if(ID < m_root.m_right.getID()){
                m_root.setRight(splay(m_root.getRight().getLeft(), ID));
                if(m_root.m_right.m_left != null){
                    m_root.m_right = rightRotate(m_root.m_right);
                }
            }
            //Final rotation to splay node to the root
            if(m_root.m_right == null){
                return m_root;
            } else {
                return leftRotate(m_root);
            }
        }
    } 


 private Customer splay(Customer node, Customer aCustomer) {
        // Base case if node is null or id is found
        if (node == null || node.getID() == aCustomer.getID()) {
            return node;
        }
    
        // Our ID is in the left subtree
        if (aCustomer.getID() < node.getID()) {
            // If left child is null return node
            if (node.getLeft() == null) {
                return node;
            }

            // Zig-Zig (Left Left)
            if (aCustomer.getID() < node.getLeft().getID()) {
                // splay the left left grandchild
                node.getLeft().setLeft(splay(node.getLeft().getLeft(), aCustomer));
                // perform first right rotation
                node = rightRotateSplay(node);
            }
            // Zig-Zag (Left Right)
            else if (aCustomer.getID() > node.getLeft().getID()) {
                // splay the left right grandchild
                node.getLeft().setRight(splay(node.getLeft().getRight(), aCustomer));
                // perform left rotation on left child
                if (node.getLeft().getRight() != null) {
                    node.setLeft(leftRotateSplay(node.getLeft()));
                }
            }
    
            //second right rotation if needed
            if (node.getLeft() == null) {
                return node;
            } else {
                // Final rotation
                node = rightRotateSplay(node);
                return node;
            }
        } else {
            // Our id in the right subtree
            // If right child is null return node
            if (node.getRight() == null) {
                return node;
            }
            
            // Right-Right (Zig-Zig)
            if (aCustomer.getID() > node.getRight().getID()) {
                //splay the right-right grandchild
                node.getRight().setRight(splay(node.getRight().getRight(), aCustomer));
                // First rotation
                node = leftRotateSplay(node);
            }
            // Right-Left (Zig-Zag)
            else if (aCustomer.getID() < node.getRight().getID()) {
                // splay the right-left grandchild
                node.getRight().setLeft(splay(node.getRight().getLeft(), aCustomer));
                //right rotation on right child
                if (node.getRight().getLeft() != null) {
                    node.setRight(rightRotateSplay(node.getRight()));
                }
            }
            
            // Second rotation
            if (node.getRight() == null) {
                return node;
            } else {
                // Final rotation
                node = leftRotateSplay(node);
                return node;
            }
        }
    }