How to implement Inorder Traversal in a Binary Tree in Golang

Question

I am trying to implement a simple binary tree in Golang in order to understand concepts being taught in class.

I'm a bit new to Golang but at the same time, I'm having a hard time wrapping my head around the concepts of recursion and where to insert the next node.

package main

import "fmt"

type Node struct {
    data int
    right *Node
    left *Node
}

func main(){

    //driver code

    //this is the root of the tree
    root := Node{data:6}

    //set the data to the int
    //set the right and left pointers to null
    /*
     6
   /   \
 nil   nil

 */

 n1 := Node{data: 8}
 n2 := Node{data: 4}
 n3 := Node{data: 10}
 root.insert(&n1)
 root.insert(&n2)
 root.insert(&n3)

 inorder(&root)

}

func (n *Node) insert(newNode *Node){
    if n.left == nil && newNode.data < n.data {
        fmt.Println("added to the left")
    }else if n.right == nil && newNode.data > n.data {
        fmt.Println("added to the right")
    }else{
        print("recurse")
        n.insert(newNode)
    }
}

func inorder(rt *Node){
    if rt == nil {
        fmt.Print("|")
        return
    }

    inorder(rt.left)
    fmt.Print(rt.data)
    inorder(rt.right)
}

The output I am getting is:

added to the right
added to the left
added to the right
|6|

The expected output should be:

added to the right
added to the left
recurse
added to the right
4 6 8 10

Any help is greatly appreciated.

You need to decide which side of the tree then if the node isn't nil recurse, else just add it there. Note that you need to make sure you handle the case where the data values are equal. — AJR, Jul 02 '19 at 00:09
Thank you for responding. I need to decide which side of the tree to add the node on (is that what you are asking)? Values lower than the node should insert on the left while values higher than a node should insert on the right. — Ikechukwu Anude, Jul 02 '19 at 00:27
Sorry I didn't explain well. The first things is to decide which side of the node it goes - so you need a 2 way branch (if) not 3 way as you have. Within each side: if the branch is nil just add it there otherwise recursively add it to that sub-tree. I added some code in the answer below. (I did it off the top of my head and it had a bug but is fixed now). — AJR, Jul 02 '19 at 00:37

AJR · Accepted Answer · 2019-07-02T00:39:56.347

This code will insert duplicate on the right. You may want to ignore duplicates (with commented out line).

func (n *Node) insert(newNode *Node){
    if newNode.data < n.data {
        if n.left == nil {
            n.left = newNode
        } else {
            n.left.insert(newNode)
        }
    } else {
    //} else if newNode.data > n.data {
        if n.right == nil {
            n.right = newNode
        } else {
            n.right.insert(newNode)
        }
    }
}

How to implement Inorder Traversal in a Binary Tree in Golang

1 Answers1