Golang树结构的实现

Golang树结构的实现。

 

树结构Golang源代码：

 

/*
**
** Version : 0.1
**
 */

package mnds

import (
    "errors"
    "fmt"
    "strings"
)

type Tree struct {
    name   string
    parent *Tree
    son    []*Tree
}

func (this *Tree) Create(name string) {
    this.name = name
    this.son = nil
}

func (this *Tree) GetName() string {
    // Bug: when this is root, can get an nil parent point, it will panic...
    return this.name
}

func (this *Tree) GetSon(nameofson string) (son *Tree, err error) {
    for _, v := range this.son {
        if v.GetName() == nameofson {
            return v, nil
        }
    }
    return nil, errors.New("No son's name call" + nameofson)
}

func (this *Tree) GetParent() *Tree {
    return this.parent
}

func (this *Tree) GetPath() []*Tree {
    var path []*Tree

    path = append(path, this)
    p := this.parent
    if p != nil {
        path = append(path, p.GetPath()...)
    }

    return path
}

func (this *Tree) AddSon(son interface{}) {
    switch son.(type) {
    case string:
        var Son Tree
        Son.name = son.(string)
        Son.parent = this
        this.son = append(this.son, &Son)
    case *Tree:
        this.son = append(this.son, son.(*Tree))
        son.(*Tree).parent = this
    default:
        break
    }
}

func (this *Tree) DeleteSon(nameofson string) {
    for k, v := range this.son {
        if v.GetName() == nameofson {
            this.son = append(this.son[:k], this.son[(k+1):]...)
        }
    }
}

func (this *Tree) FindNode(nameofnode string) []*Tree {
    var t []*Tree

    if strings.Contains(this.GetName(), nameofnode) {
        t = append(t, this)
    } else {
        if this.son == nil {
            t = nil
        } else {
            for _, v := range this.son {
                t = append(t, v.FindNode(nameofnode)...)
            }
        }
    }

    return t
}

func (this Tree) GetDegree() int {
    degree := len(this.son)

    if this.son != nil {
        for _, v := range this.son {
            if degree < v.GetDegree() {
                degree = v.GetDegree()
            }
        }
    }

    return degree
}

func (this Tree) GetDepth() int {
    var depth int
    p := this.parent
    if p == nil {
        depth = 0
    } else {
        depth = p.GetDepth() + 1
    }

    return depth
}

func (this Tree) GetHeight() int {
    var height int = 0

    if this.son == nil {
        height = 0
    } else {
        sonheight := make([]int, len(this.son))
        // Get all height of sons
        for k, v := range this.son {
            if v.son != nil {
                // If have son, get its height, and must add 1
                sonheight[k] = v.GetHeight() + 1
            } else {
                // If son havn't son, and his parent's height is 1
                height = 1
            }
        }

        // Get the max height
        for _, v := range sonheight {
            if height < v {
                height = v
            }
        }
    }

    return height
}

// To show all data of the tree.
// You can get all data of the tree like this.
func (this Tree) ShowAll() {
    for k := 0; k < this.GetDepth(); k++ {
        fmt.Printf("  ")
    }
    fmt.Printf("%s\n", this.GetName())
    if this.son != nil {
        for _, v := range this.son {
            for k := 0; k < v.GetDepth(); k++ {
                fmt.Printf("  ")
            }
            v.ShowAll()
        }
    }
}

func (this Tree) ToJson() []byte {

    return nil
}

func (this *Tree) FromJson(data []byte) error {

    return nil
}

func (this Tree) ToMap() map[string]string {

    return nil
}

func (this *Tree) FromMap(data map[string]string) error {

    return nil
}

 

测试代码：

 

package main

import (
    "fmt"

    "merrynuts/mnds"
)

type country struct {
    mnds.Tree
    countryname string `json:"countryname"`
}

func main() {
    var china country
    var shanghai mnds.Tree
    var leliu mnds.Tree

    china.Create("中国")
    china.countryname = china.GetName()
    fmt.Println(china.countryname)

    china.AddSon("广东省")
    china.AddSon("吉林省")
    china.AddSon("广西壮族自治区")
    china.AddSon("湖南省")
    china.AddSon("湖北省")

    hn, err := china.GetSon("湖南省")
    if err != nil {
        fmt.Println(china.GetName(), "没有一个叫湖南省的儿子")
    } else {
        hn.AddSon("长沙市")
        hn.AddSon("衡阳市")
        hn.AddSon("张家界市")
        cs, err := hn.GetSon("长沙市")
        if err != nil {
            fmt.Println(cs.GetName(), "没有一个叫长沙市的儿子")
        } else {
            cs.AddSon("芙蓉区")
            cs.AddSon("天心区")
            cs.AddSon("岳麓区")
            cs.AddSon("开福区")
            cs.AddSon("雨花区")
            cs.AddSon("长沙县")
            cs.AddSon("望城区")
            cs.AddSon("浏阳市")
            cs.AddSon("宁乡市")
        }
    }

    gd, err := china.GetSon("广东省")
    if err != nil {
        fmt.Println(china.GetName(), "没有一个叫广东省的儿子")
    } else {
        gd.AddSon("深圳市")
        gd.AddSon("广州市")
        gd.AddSon("佛山市")
        gd.AddSon("中山市")
        gd.AddSon("东莞市")
        fs, err := gd.GetSon("佛山市")
        if err != nil {
            fmt.Println(gd.GetName(), "没有一个叫佛山市的儿子")
        } else {
            fs.AddSon("顺德区")
            fs.AddSon("南海区")
            fs.AddSon("禅城区")
            fs.AddSon("三水区")
            fs.AddSon("高明区")
            sd, err := fs.GetSon("顺德区")
            if err != nil {
                fmt.Println(fs.GetName(), "没有一个叫顺德区的儿子")
            } else {
                sd.AddSon("大良街道")
                sd.AddSon("龙江街道")
                sd.AddSon("伦教街道")
                sd.AddSon("乐从街道")
                sd.AddSon("容桂街道")
                sd.AddSon("杏坛街道")
                sd.AddSon("均安街道")

                leliu.Create("勒流街道")
                sd.AddSon(&leliu)
            }

            nh, err := fs.GetSon("南海区")
            if err != nil {
                fmt.Println(fs.GetName(), "没有一个叫南海区的儿子")
            } else {
                nh.AddSon("狮山街道")
                nh.AddSon("罗村街道")
                nh.AddSon("丹灶街道")
            }
        }
    }

    gx, err := china.GetSon("广西壮族自治区")
    if err != nil {
        fmt.Println(china.GetName(), "没有一个叫广西壮族自治区的儿子")
    } else {
        gx.AddSon("桂林市")
        gx.AddSon("柳州市")
        gx.AddSon("梧州市")
        gx.AddSon("北海市")
        gl, err := gx.GetSon("桂林市")
        if err != nil {
            fmt.Println(gx.GetName(), "没有一个叫桂林市的儿子")
        } else {
            gl.AddSon("桂平市")
            gl.AddSon("顺德区")
        }
        var hechen mnds.Tree
        hechen.Create("河辰市")
        gx.AddSon(&hechen)
    }

    shanghai.Create("上海市")
    shanghai.AddSon("静安区")
    shanghai.AddSon("浦东区")
    china.AddSon(&shanghai)

    fmt.Println(china.GetName(), "的整体结构如下：")
    fmt.Println("===========================================================")
    china.ShowAll()
    fmt.Println("-----------------------------------------------------------")

    for {
        var ss string
        fmt.Printf("Search? ")
        fmt.Scanf("%s\n", &ss)
        if ss == "exit" {
            break
        }
        result := china.FindNode(ss)
        if result == nil {
            fmt.Println("Can't find the node name's", ss)
        } else {
            for k, v := range result {
                fmt.Println("===========================================================")
                fmt.Println("Find the no.", k+1 , "of node name's", ss, "It's path to root is :")
                path := v.GetPath()
                for k := len(path) - 1; k >= 0; k-- {
                    if k > 0 {
                        fmt.Printf("%s-->", path[k].GetName())
                    } else {
                        fmt.Printf("%s", path[k].GetName())
                    }
                }
                fmt.Println()
                fmt.Println("It's structure is :")
                v.ShowAll()
                fmt.Println("-----------------------------------------------------------")
            }
        }
    }
}

 

 

运行效果：

 

D:\project\merrynuts\src>merrynuts
中国
中国 的整体结构如下：
===========================================================
中国
    广东省
        深圳市
        广州市
        佛山市
            顺德区
                大良街道
                龙江街道
                伦教街道
                乐从街道
                容桂街道
                杏坛街道
                均安街道
                勒流街道
            南海区
                狮山街道
                罗村街道
                丹灶街道
            禅城区
            三水区
            高明区
        中山市
        东莞市
    吉林省
    广西壮族自治区
        桂林市
            桂平市
            顺德区
        柳州市
        梧州市
        北海市
        河辰市
    湖南省
        长沙市
            芙蓉区
            天心区
            岳麓区
            开福区
            雨花区
            长沙县
            望城区
            浏阳市
            宁乡市
        衡阳市
        张家界市
    湖北省
    上海市
        静安区
        浦东区
-----------------------------------------------------------
Search?