Data commit

Task/Tree-traversal/Go/tree-traversal-1.go

@@ -0,0 +1,86 @@
+package main
+
+import "fmt"
+
+type node struct {
+    value       int
+    left, right *node
+}
+
+func (n *node) iterPreorder(visit func(int)) {
+    if n == nil {
+        return
+    }
+    visit(n.value)
+    n.left.iterPreorder(visit)
+    n.right.iterPreorder(visit)
+}
+
+func (n *node) iterInorder(visit func(int)) {
+    if n == nil {
+        return
+    }
+    n.left.iterInorder(visit)
+    visit(n.value)
+    n.right.iterInorder(visit)
+}
+
+func (n *node) iterPostorder(visit func(int)) {
+    if n == nil {
+        return
+    }
+    n.left.iterPostorder(visit)
+    n.right.iterPostorder(visit)
+    visit(n.value)
+}
+
+func (n *node) iterLevelorder(visit func(int)) {
+    if n == nil {
+        return
+    }
+    for queue := []*node{n}; ; {
+        n = queue[0]
+        visit(n.value)
+        copy(queue, queue[1:])
+        queue = queue[:len(queue)-1]
+        if n.left != nil {
+            queue = append(queue, n.left)
+        }
+        if n.right != nil {
+            queue = append(queue, n.right)
+        }
+        if len(queue) == 0 {
+            return
+        }
+    }
+}
+
+func main() {
+    tree := &node{1,
+        &node{2,
+            &node{4,
+                &node{7, nil, nil},
+                nil},
+            &node{5, nil, nil}},
+        &node{3,
+            &node{6,
+                &node{8, nil, nil},
+                &node{9, nil, nil}},
+            nil}}
+    fmt.Print("preorder:    ")
+    tree.iterPreorder(visitor)
+    fmt.Println()
+    fmt.Print("inorder:     ")
+    tree.iterInorder(visitor)
+    fmt.Println()
+    fmt.Print("postorder:   ")
+    tree.iterPostorder(visitor)
+    fmt.Println()
+    fmt.Print("level-order: ")
+    tree.iterLevelorder(visitor)
+    fmt.Println()
+}
+
+func visitor(value int) {
+    fmt.Print(value, " ")
+}

Task/Tree-traversal/Go/tree-traversal-2.go

@@ -0,0 +1,71 @@
+package main
+
+import "fmt"
+
+// flat, level-order representation.
+// for node at index k, left child has index 2k, right child has index 2k+1.
+// a value of -1 means the node does not exist.
+type tree []int
+
+func main() {
+    t := tree{1, 2, 3, 4, 5, 6, -1, 7, -1, -1, -1, 8, 9}
+    visitor := func(n int) {
+        fmt.Print(n, " ")
+    }
+    fmt.Print("preorder:    ")
+    t.iterPreorder(visitor)
+    fmt.Print("\ninorder:     ")
+    t.iterInorder(visitor)
+    fmt.Print("\npostorder:   ")
+    t.iterPostorder(visitor)
+    fmt.Print("\nlevel-order: ")
+    t.iterLevelorder(visitor)
+    fmt.Println()
+}
+
+func (t tree) iterPreorder(visit func(int)) {
+    var traverse func(int)
+    traverse = func(k int) {
+        if k >= len(t) || t[k] == -1 {
+            return
+        }
+        visit(t[k])
+        traverse(2*k + 1)
+        traverse(2*k + 2)
+    }
+    traverse(0)
+}
+
+func (t tree) iterInorder(visit func(int)) {
+    var traverse func(int)
+    traverse = func(k int) {
+        if k >= len(t) || t[k] == -1 {
+            return
+        }
+        traverse(2*k + 1)
+        visit(t[k])
+        traverse(2*k + 2)
+    }
+    traverse(0)
+}
+
+func (t tree) iterPostorder(visit func(int)) {
+    var traverse func(int)
+    traverse = func(k int) {
+        if k >= len(t) || t[k] == -1 {
+            return
+        }
+        traverse(2*k + 1)
+        traverse(2*k + 2)
+        visit(t[k])
+    }
+    traverse(0)
+}
+
+func (t tree) iterLevelorder(visit func(int)) {
+    for _, n := range t {
+        if n != -1 {
+            visit(n)
+        }
+    }
+}