1. package main
    3. import "fmt"
    5. type Node struct {
    6.     Val int
    7.     Next *Node
    8. }
    10. type List struct {
    11.     HeadNode *Node
    12. }
    14. func main() {
    15.     list := NewList()
    17.     // ["MyLinkedList","addAtHead","addAtTail","addAtIndex","get","deleteAtIndex","get"]
    18.     // [[],[1],[3],[1,2],[1],[0],[0]]
    19.     list.AddAtHead(1)
    20.     list.Show()
    21.     list.AddAtTail(3)
    22.     list.Show()
    23.     list.AddAtIndex(1, 2)
    24.     list.Show()
    25.     fmt.Println("No.1:", list.Get(1))
    26.     list.DeleteAtIndex(0)
    27.     list.Show()
    28.     fmt.Println("No.0:", list.Get(0))
    30.     /*list.AddAtHead(1)
    31.     list.Show()
    32.     list.AddAtHead(2)
    33.     list.Show()
    34.     fmt.Println("No.0:", list.Get(0))
    35.     fmt.Println("No.1:", list.Get(1))
    36.     fmt.Println("No.4:", list.Get(4))
    37.     list.AddAtHead(3)
    38.     list.Show()
    39.     list.AddAtTail(4)
    40.     list.Show()
    41.     fmt.Println("No.2:", list.Get(2))
    42.     list.AddAtTail(5)
    43.     list.Show()
    44.     list.AddAtIndex(2, 0)
    45.     list.Show()
    46.     fmt.Println("No.3:", list.Get(3))
    47.     list.DeleteAtIndex(2)
    48.     list.Show()
    49.     fmt.Println("No.3:", list.Get(3))*/
    50. }
    52. func NewList() *List {
    53.     return &List{HeadNode: nil}
    54. }
    56. func (l *List) IsEmpty() bool {
    57.     if l.HeadNode == nil {
    58.         return true
    59.     } else {
    60.         return false
    61.     }
    62. }
    64. func (l *List) GetLen() int {
    65.     cur := l.HeadNode
    66.     count := 0
    67.     for cur != nil {
    68.         cur = cur.Next
    69.         count++
    70.     }
    71.     return count
    72. }
    74. func (l *List) Get(index int) int {
    75.     if l.HeadNode == nil || index >= l.GetLen() {
    76.         return -1
    77.     }
    78.     i := 0
    79.     cur := l.HeadNode
    80.     for {
    81.         if i == index {
    82.             return cur.Val
    83.         }
    84.         cur = cur.Next
    85.         i++
    86.     }
    87.     return -1
    88. }
    90. func (l *List) AddAtHead(val int) {
    91.     node := &Node{
    92.         Val: val,
    93.         Next: l.HeadNode,
    94.     }
    95.     l.HeadNode = node
    96. }
    98. func (l *List) AddAtTail(val int) {
    99.     node := &Node{Val: val}
    100.     if l.IsEmpty() {
    101.         l.HeadNode = node
    102.     } else {
    103.         cur := l.HeadNode
    104.         for cur.Next != nil {
    105.             cur = cur.Next
    106.         }
    107.         cur.Next = node
    108.     }
    109. }
    111. func (l *List) AddAtIndex(index, val int) {
    112.     if index <= 0 {
    113.         l.AddAtHead(val)
    114.         return
    115.     }
    116.     if index > l.GetLen() {
    117.         return
    118.     }
    119.     if index == l.GetLen() {
    120.         l.AddAtTail(val)
    121.         return
    122.     }
    123.     i := 0
    124.     node := &Node{Val: val}
    125.     cur := l.HeadNode
    126.     for {
    127.         if i+1 == index {
    128.             node.Next = cur.Next
    129.             cur.Next = node
    130.             break
    131.         }
    132.         cur = cur.Next
    133.         i++
    134.     }
    135. }
    137. func (l *List) DeleteAtIndex(index int) {
    138.     if index < 0 || l.GetLen() == 0 || index >= l.GetLen() {
    139.         return
    140.     }
    141.     if l.GetLen() == 1 {
    142.         l.HeadNode = nil
    143.         return
    144.     }
    145.     if index == 0 {
    146.         l.HeadNode = l.HeadNode.Next
    147.         return
    148.     }
    149.     i := 0
    150.     cur := l.HeadNode
    151.     for {
    152.         if i+1 == index {
    153.             cur.Next = cur.Next.Next
    154.             break
    155.         }
    156.         cur = cur.Next
    157.         i++
    158.     }
    159. }
    161. func (l *List) Show() {
    162.     if l.HeadNode == nil {
    163.         return
    164.     }
    165.     cur := l.HeadNode
    166.     fmt.Print(l.GetLen(), " ")
    167.     for cur != nil {
    168.         fmt.Print(cur.Val, "-> ")
    169.         cur = cur.Next
    170.     }
    171.     fmt.Println()
    172. }