Detect leaf nodes of threaded BST in golang

Go program for Detect leaf nodes in threaded BST. Here mentioned other language solution.

package main
import "fmt"
// Go program for
// Print leaf node in Threaded BST
type TreeNode struct {
    data int
    left * TreeNode
    right * TreeNode
}
func getTreeNode(data int, 
                 left * TreeNode, 
                 right * TreeNode) * TreeNode {
    // return new TreeNode
    return &TreeNode {
        data,
        left,
        right,
    }
}
type BinarySearchTree struct {
    root * TreeNode
}
func getBinarySearchTree() * BinarySearchTree {
    // return new BinarySearchTree
    return &BinarySearchTree {
        nil,
    }
}
// Added node in Threaded BST
func(this BinarySearchTree) addNode(node * TreeNode, 
                                    x * TreeNode, 
                                    y * TreeNode, 
                                    data int) * TreeNode {
    if node != nil {
        if node.data >= data {
            if node.left == x {
                node.left = getTreeNode(data, x, node)
            } else {
                node.left = this.addNode(node.left, x, node, data)
            }
        } else if node.data < data {
            if node.right == y {
                node.right = getTreeNode(data, node, y)
            } else {
                node.right = this.addNode(node.right, node, y, data)
            }
        }
        return node
    } else {
        return getTreeNode(data, x, y)
    }
}
// Adding a new node in binary search tree
func(this *BinarySearchTree) add(data int) {
    this.root = this.addNode(this.root, nil, nil, data)
}
// Print all leaf node in Threaded BST
func(this BinarySearchTree) leafNode(node, x, y *TreeNode) {
    if node != nil {
        if node.left == x && node.right == y {
            // This is a leaf node Then print
            fmt.Print("  ", node.data)
            return
        }
        if node.left != x {
            // Visit left child
            this.leafNode(node.left, x, node)
        }
        if node.right != y {
            // Visit right child
            this.leafNode(node.right, node, y)
        }
    }
}
func main() {
    var tree * BinarySearchTree = getBinarySearchTree()
    // Add nodes in binary search tree
    /*
                5
               / \
              /   \
             /     \
            3       9
           / \     / \
          1   4   8   11
         / \     /      \
       -3   2   7        12
            
    */
    tree.add(5)
    tree.add(3)
    tree.add(9)
    tree.add(1)
    tree.add(4)
    tree.add(8)
    tree.add(11)
    tree.add(-3)
    tree.add(2)
    tree.add(7)
    tree.add(12)
    // Test
    tree.leafNode(tree.root, nil, nil)
}

Output

  -3  2  4  7  12