1. package link_list
    3. import "fmt"
    5. type LinkNode struct {
    6.     Value interface{}
    7.     Next  *LinkNode
    8. }
    10. type NodeList struct {
    11.     Node   *LinkNode
    12.     Length int
    13. }
    15. func NewLinkNode() *LinkNode {
    16.     return &LinkNode{Value: 0, Next: nil}
    17. }
    19. // 获取链表的值
    20. func (l *LinkNode) GetValue() interface{} {
    21.     return l.Value
    22. }
    24. // 获取链表的下一个节点
    25. func (l *LinkNode) GetNode() *LinkNode {
    26.     return l.Next
    27. }
    29. func NewNodeList() *NodeList {
    30.     return &NodeList{Node: NewLinkNode(), Length: 0}
    31. }
    33. // 在某个节点后面插入节点
    34. func (n *NodeList) InsertAfterNode(node *LinkNode, value interface{}) bool {
    35.     if node == nil {
    36.         return false
    37.     }
    39.     newNode := NewLinkNode()
    40.     newNode.Value = value
    41.     newNode.Next = node.Next
    42.     node.Next = newNode
    43.     n.Length++
    45.     return true
    46. }
    48. // 在某个节点前面插入节点
    49. func (n *NodeList) InsertBeforeNode(node *LinkNode, value interface{}) bool {
    50.     if node == nil || node == n.Node {
    51.         return false
    52.     }
    53.     // 获取全部的节点，与传入的节点进行比较
    54.     cur := n.Node.Next
    55.     pre := n.Node
    57.     for cur != nil {
    58.         if cur == node {
    59.             break
    60.         }
    62.         pre = cur
    63.         cur = cur.Next
    64.     }
    66.     if cur == nil {
    67.         return false
    68.     }
    69.     // 此时cur节点就是p节点
    70.     newNode := NewLinkNode()
    71.     newNode.Next = cur
    72.     newNode.Value = value
    73.     pre.Next = newNode
    74.     n.Length++
    75.     return true
    77. }
    79. // 在链表的头部插入节点
    80. func (n *NodeList) InsertHeadNode(v interface{}) {
    81.     n.InsertAfterNode(n.Node, v)
    82. }
    84. // 在链表尾部插入节点
    85. func (n *NodeList) InsertTailNode(v interface{}) {
    86.     cur := n.Node
    88.     for cur.Next != nil {
    89.         cur = cur.Next
    90.     }
    92.     n.InsertAfterNode(cur, v)
    94. }
    96. // 删除传入的节点
    97. func (n *NodeList) DelNode(node *LinkNode) bool {
    98.     if node == nil {
    99.         return false
    100.     }
    102.     cur := n.Node.Next
    103.     pre := n.Node
    105.     for nil != cur {
    106.         if cur == node {
    107.             break
    108.         }
    110.         pre = cur
    111.         cur = cur.Next
    112.     }
    114.     if cur == nil {
    115.         return false
    116.     }
    117.     pre.Next = cur.Next
    118.     n.Length--
    119.     return true
    120. }
    122. // 遍历所有的节点
    123. func (n *NodeList) Print() {
    124.     cur := n.Node.Next
    126.     var format = ""
    127.     for cur != nil {
    128.         format += fmt.Sprintf("%+v", cur.GetValue())
    129.         cur = cur.Next
    130.         if nil != cur {
    131.             format += "->"
    132.         }
    133.     }
    134.     fmt.Println(format)
    135. }
    137. // 测试用例
    138. func TestList(t *testing.T) {
    139.     nodeList := NewNodeList()
    140.     nodeList.InsertAfterNode(nodeList.Node, 1)
    141.     nodeList.InsertAfterNode(nodeList.Node.Next, 2)
    142.     nodeList.InsertAfterNode(nodeList.Node.Next.Next, 3)
    143.     nodeList.InsertBeforeNode(nodeList.Node.Next.Next, 4)
    144.     nodeList.InsertHeadNode(5)
    145.     nodeList.InsertTailNode(6)
    146.     nodeList.DelNode(nodeList.Node.Next.Next)
    147.     nodeList.Print()
    148.     fmt.Println(nodeList.Length)
    150. }
    152. // 测试结果 5->4->2->3->6  5