golang实现单链表

 package main
 
 import "fmt"
 
 type Object interface{}
 
 type Node struct {
     data Object
     next *Node
 }
 
 type List struct {
     headNode *Node
 }
 
 func NewNode(data Object, next *Node) *Node {
     return &Node{data, next}
 }
 
 func (list *List) IsEmpty() bool {
     return list.headNode == nil
 }
 
 func (list *List) Add(node *Node) *List {
     headNode := list.headNode
     if headNode.next != nil {
         node.next = headNode.next
     }
     headNode.next = node
     return list
 }
 
 func (list *List) Append(node *Node) *List {
     if list.IsEmpty() {
         list.headNode = node
         return list
     }
     curNode := list.headNode
     for curNode.next != nil {
         curNode = curNode.next
     }
     curNode.next = node
     return list
 }
 
 func (list *List) Insert(index int, data Object) {
     if (index >=  && index < list.Length()) {
         count :=
         if !list.IsEmpty() {
             curNode := list.headNode
             for curNode != nil && count < index {
                 count++
                 curNode = curNode.next
             }
             node := NewNode(data, curNode.next)
             curNode.next = node
         }
     }
 }
 
 func (list *List) Remove(index int) {
     if (index >=  && index < list.Length()) {
         count :=
         if !list.IsEmpty() {
             curNode := list.headNode
             for curNode != nil && count < index- {
                 count++
                 curNode = curNode.next
             }
             curNode.next = curNode.next.next
         }
     }
 }
 
 func PrintList(list *List) {
     cur := list.headNode
     for cur != nil {
         fmt.Println(cur.data)
         cur = cur.next
     }
 }
 
 func (list *List) Length() int {
     var length int
     curNode := list.headNode
     for curNode != nil {
         length++
         curNode = curNode.next
     }
     return length
 }
 
 func ReverseList(head *Node) *Node {
     cur := head
     var pre *Node = nil
     for cur != nil {
         pre, cur, cur.next = cur, cur.next, pre
     }
     return cur
 }
 
 func main(){
     fmt.Println("NewNode======================")
     node := NewNode(, nil)
     fmt.Println(node.data)
     list := &List{node}
     PrintList(list)
     node2 := NewNode("a", nil)
     list.Append(node2)
     fmt.Println("Add======================")
     PrintList(list)
     node1 := NewNode(, nil)
     list.Add(node1)
     fmt.Println("Length======================")
     PrintList(list)
     fmt.Println(list.Length())
     fmt.Println("Insert======================")
     list.Insert(, )
     PrintList(list)
     fmt.Println("Remove======================")
     list.Remove()
     PrintList(list)
     fmt.Println("ReverseList======================")
     ReverseList(node)
     PrintList(list)
 }