Count complete odd nodes path of binary tree in golang

Go program for Count complete odd nodes path of binary tree. Here more solutions.

package main
import "fmt"
/* 
  Go program for
  Count odd paths in Binary Tree
*/
// Binary Tree node
type TreeNode struct {
    data int
    left * TreeNode
    right * TreeNode
}
func getTreeNode(data int) * TreeNode {
    // return new TreeNode
    return &TreeNode {
        data,
        nil,
        nil,
    }
}
type BinaryTree struct {
    root * TreeNode
}
func getBinaryTree() * BinaryTree {
    // return new BinaryTree
    return &BinaryTree {
        nil,
    }
}
// Count all paths from root to leaf
// which containing all Odd nodes
func(this BinaryTree) countOddNodePath(node * TreeNode) int {
    if node == nil || node.data % 2 == 0 {
        // When tree node is null or
        // its contain even value
        return 0
    } else {
        if node.left == nil && node.right == nil {
            // When get leaf node And
            // path contain all Odd nodes
            return 1
        }
        return this.countOddNodePath(node.left) + 
        this.countOddNodePath(node.right)
    }
}
func main() {
    // New of binary tree
    var tree * BinaryTree = getBinaryTree()
    /*
      Construct Binary Tree
      -----------------------
             5
            /  \ 
           /    \
          3      9
         / \    / \
        7   6  1   3
       / \    / \   
      10  3  7   4
    */
    // Add tree node
    tree.root = getTreeNode(5)
    tree.root.left = getTreeNode(3)
    tree.root.right = getTreeNode(9)
    tree.root.right.right = getTreeNode(3)
    tree.root.left.right = getTreeNode(6)
    tree.root.right.left = getTreeNode(1)
    tree.root.left.left = getTreeNode(7)
    tree.root.left.left.left = getTreeNode(10)
    tree.root.left.left.right = getTreeNode(3)
    tree.root.right.left.right = getTreeNode(4)
    tree.root.right.left.left = getTreeNode(7)
    /*
      Given Binary Tree
      -----------------------
             5
            /  \ 
           /    \
          3      9
         / \    / \
        7   6  1   3
       / \    / \   
      10  3  7   4
      Here
      Odd path from root to leaf
      -----------------------
             5
            /  \ 
           /    \
          3      9
         /      / \
        7      1   3
         \    /     
          3  7    
      ---------------------
        5->3->7->3    
        5->9->1->7  
        5->9->3  
      ----------------------
      Result : 3 [number of path]
    */
    // Count odd nodes paths from root
    // to leaf in a binary tree.
    fmt.Println(tree.countOddNodePath(tree.root))
}

Output

3