go-lctree alternatives and similar packages
Based on the "Serialization" category.
Alternatively, view go-lctree alternatives based on common mentions on social networks and blogs.
-
-
-
mapstructure
DISCONTINUED. Go library for decoding generic map values into native Go structures and vice versa. -
-
cbor
CBOR codec (RFC 8949) with CBOR tags, Go struct tags (toarray, keyasint, omitempty), float64/32/16, big.Int, and fuzz tested billions of execs. -
go-capnproto
Cap'n Proto library and parser for go. This is go-capnproto-1.0, and does not have rpc. See https://github.com/zombiezen/go-capnproto2 for 2.0 which has rpc and capabilities. -
bambam
auto-generate capnproto schema from your golang source files. Depends on go-capnproto-1.0 at https://github.com/glycerine/go-capnproto -
-
go-serializer
:loop: Serialize any custom type or convert any content to []byte or string, for Go Programming Language -
unitpacking
A library for storing unit vectors in a representation that lends itself to saving space on disk.
InfluxDB - Purpose built for real-time analytics at any scale.
Do you think we are missing an alternative of go-lctree or a related project?
README
lctree :seedling:
lctree provides a CLI and Golang primitives to serialize and deserialize LeetCode binary trees (e.g. "[5,4,7,3,null,2,null,-1,null,9]").
Overview | Getting Started | Contributing
Overview
- Deserialize/Serialize
- Walk Depth-First
- Walk Breadth-First
- Convert to DOT language for visualization
- CLI (see [bin/](bin/))
Getting Started
Deserialize
package main
import (
"fmt"
"github.com/sbourlon/go-lctree"
)
// Type alias
type TreeNode = lctree.TreeNode
func mySolution(root *TreeNode) {
fmt.Printf("root: %+v\n", root)
return
}
func main() {
tree := lctree.Deserialize("[1,null,2,3]")
mySolution(tree)
}
Output:
root: &{Val:1 Left:<nil> Right:0xc00008e020}
Serialize
package main
import (
"fmt"
"github.com/sbourlon/go-lctree"
)
type TreeNode = lctree.TreeNode
func mySolution() *TreeNode {
return lctree.Deserialize("[1,null,2,3]")
}
func main() {
tree := mySolution()
fmt.Println(lctree.Serialize(tree))
}
Output:
[1,null,2,3]
Walk Depth-First
package main
import (
"fmt"
"github.com/sbourlon/go-lctree"
)
type TreeNode = lctree.TreeNode
func mySolution() *TreeNode {
return lctree.Deserialize("[1,null,2,3]")
}
func main() {
tree := mySolution()
walkFn := func(n *TreeNode) error {
fmt.Printf("%+v\n", n)
return nil
}
tree.WalkDepthFirst(walkFn)
}
Output:
&{Val:1 Left:<nil> Right:0xc00000c0a0}
&{Val:2 Left:0xc00000c0c0 Right:<nil>}
&{Val:3 Left:<nil> Right:<nil>}
Walk Breadth-First
package main
import (
"fmt"
"github.com/sbourlon/go-lctree"
)
type TreeNode = lctree.TreeNode
func mySolution() *TreeNode {
return lctree.Deserialize("[1,null,2,3]")
}
func main() {
tree := mySolution()
walkFn := func(n *TreeNode, depth int) error {
fmt.Printf("depth: %d\t%+v\n", depth, n)
return nil
}
tree.WalkBreadthFirst(walkFn)
}
Output:
depth: 0 &{Val:1 Left:<nil> Right:0xc00000c0a0}
depth: 1 <nil>
depth: 1 &{Val:2 Left:0xc00000c0c0 Right:<nil>}
depth: 2 &{Val:3 Left:<nil> Right:<nil>}
depth: 2 <nil>
depth: 3 <nil>
depth: 3 <nil>
Convert to DOT language for visualization
package main
import (
"fmt"
"github.com/sbourlon/go-lctree"
)
type TreeNode = lctree.TreeNode
func mySolution() *TreeNode {
return lctree.Deserialize("[10,5,15,null,null,6,20]")
}
func main() {
tree := mySolution()
fmt.Println(tree.DOT())
}
Output:
digraph {
graph [ordering="out"];
10;
5;
15;
6;
20;
10 -> 5;
10 -> 15;
15 -> 6;
15 -> 20;
}
then convert into a png picture (e.g. tree.png):
$ dot -Tpng -o tree.png tree.dot
Output:
[tree.png](img/tree.png "Tree PNG image from DOT")
Contributing
Pull-requests, feature requests and issues are welcome.
License
[ISC license](LICENSE.md)
*Note that all licence references and agreements mentioned in the go-lctree README section above
are relevant to that project's source code only.