美文网首页
数据结构:Go语言实现单向链表

数据结构:Go语言实现单向链表

作者: 沙漠中的猴 | 来源:发表于2018-11-19 17:45 被阅读0次

    代码

    package main
    
    import "fmt"
    
    type Element interface{}
    
    type Node struct {
        Data Element
        Next *Node
    }
    
    type List struct {
        Head   *Node
        Length int
    }
    
    /*
       当链表中只包含头节点,则链表长度为0,称为空链表。 当插入元素是,也是忽略头节点进行的操作。
    */
    
    // 创建空链表
    //创建链表的时候,不需要传入参数,直接返回一个链表就ok
    func Create() *List {
        head := new(Node)
        return &List{Head: head, Length: 0}
    }
    
    // 获取链表的长度。返回 0 则为空
    func (l *List) Len() int {
        return l.Length
    }
    
    //判断链表是否为空。为空则返回 true
    func (l *List) IsEmpty() bool {
        if l.Head.Next != nil {
            return false
        }
    
        return true
    }
    
    // 在链表后追加元素
    func (l *List) Append(e Element) {
        node := &Node{Data: e, Next: nil}
        p := l.Head
    
        // 如果链表不为空则遍历
        if !l.IsEmpty() {
            for p.Next != nil {
                p = p.Next
            }
        }
        p.Next = node
        l.Length++
        return
    }
    
    // 在链表前追加元素
    func (l *List) PreAppend(e Element) {
        node := &Node{Data: e, Next: nil}
    
        node.Next = l.Head.Next
        l.Head.Next = node
    
        l.Length++
    
        return
    }
    
    // 向链表的指定位置插入元素
    func (l *List) Insert(index int, e Element) {
        if index < 0 || l.IsEmpty() {
            l.PreAppend(e)
        } else if index > l.Len() {
            l.Append(e)
        } else {
            p := l.Head
    
            for i := 0; i < index-1; i++ {
                p = p.Next
            }
    
            node := &Node{Data: e, Next: nil}
    
            node.Next = p.Next
            p.Next = node
    
            l.Length++
        }
    
        return
    }
    
    // 获取指定位置的元素信息
    func (l *List) GetEle(index int) Element {
        if l.IsEmpty() || index > l.Len() || index < 0 {
            fmt.Println("no data")
        }
    
        p := l.Head.Next
        for i := 1; i < index; i++ {
            p = p.Next
        }
    
        return p.Data
    }
    
    // 打印链表信息
    func (l *List) Print() {
        if l.IsEmpty() {
            fmt.Println(" list is empty")
            return
        }
    
        p := l.Head.Next
        i := 1
        for p != nil {
    
            fmt.Printf("iNode:%d, data: %#v\n", i, p.Data)
            i++
            p = p.Next
    
        }
    }
    
    //删除指定位置的链表元素。
    func (l *List) Delete(index int) {
        p := l.Head
    
        for i := 0; i < index-1; i++ {
            p = p.Next
        }
    
        p.Next = p.Next.Next
        l.Length--
    }
    
    // 清空链表
    func (l *List) Empty() {
        l.Head.Next = nil
        l.Length = 0
    }
    
    func main() {
        l := Create()
    
        l.Append(111)
        l.Insert(2, 222)
        l.Insert(4, 444)
        l.Insert(3, 333)
        l.Insert(3, 555)
    
        l.Delete(2)
    
        fmt.Println(l.GetEle(2))
    
        l.Print()
        fmt.Println(l.Len())
    
        l.Empty()
    
        l.Print()
        fmt.Println(l.Len())
    
    }
    
    

    相关文章

      网友评论

          本文标题:数据结构:Go语言实现单向链表

          本文链接:https://www.haomeiwen.com/subject/xwyafqtx.html