1. package main
    3. import "fmt"
    5. type Node struct {
    6.     Val  int
    7.     Prev *Node
    8.     Next *Node
    9. }
    11. type List struct {
    12.     Head   *Node
    13.     Tail   *Node
    14.     Length int
    15. }
    17. func main() {
    18.     list := Constructor()
    19.     list.Show()
    20.     fmt.Println("No.-1: ", list.Get(-1))
    21.     fmt.Println("No.0: ", list.Get(0))
    22.     fmt.Println("No.1: ", list.Get(1))
    23.     list.AddAtHead(1)
    24.     list.Show()
    25.     fmt.Println("No.-1: ", list.Get(-1))
    26.     fmt.Println("No.0: ", list.Get(0))
    27.     fmt.Println("No.1: ", list.Get(1))
    28.     list.AddAtHead(2)
    29.     list.Show()
    30.     fmt.Println("No.-1: ", list.Get(-1))
    31.     fmt.Println("No.0: ", list.Get(0))
    32.     fmt.Println("No.1: ", list.Get(1))
    33.     list.AddAtHead(3)
    34.     list.Show()
    35.     fmt.Println("No.-1: ", list.Get(-1))
    36.     fmt.Println("No.0: ", list.Get(0))
    37.     fmt.Println("No.1: ", list.Get(1))
    38.     fmt.Println("No.2: ", list.Get(2))
    39.     fmt.Println("No.3: ", list.Get(3))
    40.     fmt.Println("No.4: ", list.Get(4))
    41.     list.AddAtTail(4)
    42.     list.AddAtTail(5)
    43.     list.AddAtTail(6)
    44.     list.Show()
    45.     fmt.Println("No.-1: ", list.Get(-1))
    46.     fmt.Println("No.0: ", list.Get(0))
    47.     fmt.Println("No.1: ", list.Get(1))
    48.     fmt.Println("No.2: ", list.Get(2))
    49.     fmt.Println("No.3: ", list.Get(3))
    50.     fmt.Println("No.4: ", list.Get(4))
    51.     fmt.Println("No.5: ", list.Get(5))
    52.     fmt.Println("No.6: ", list.Get(6))
    53.     list.AddAtIndex(3, 9)
    54.     list.AddAtIndex(0, 8)
    55.     list.AddAtIndex(-1, 9)
    56.     list.AddAtIndex(0, 8)
    57.     list.AddAtIndex(20, 20)
    58.     list.AddAtIndex(10, 10)
    59.     list.Show()
    60.     list.DeleteAtIndex(-1)
    61.     list.DeleteAtIndex(0)
    62.     list.DeleteAtIndex(2)
    63.     list.DeleteAtIndex(8)
    64.     list.DeleteAtIndex(8)
    65.     list.Show()
    67. }
    69. func Constructor() *List {
    70.     head := &Node{
    71.         Val:  0,
    72.         Prev: nil,
    73.         Next: nil,
    74.     }
    75.     tail := &Node{
    76.         Val:  0,
    77.         Prev: nil,
    78.         Next: nil,
    79.     }
    80.     head.Next = tail
    81.     tail.Prev = head
    82.     list := &List{
    83.         Head:   head,
    84.         Tail:   tail,
    85.         Length: 0,
    86.     }
    87.     return list
    88. }
    90. func (list *List) Get(index int) (val int) {
    91.     if list.Head.Next == list.Tail {
    92.         return -1
    93.     }
    94.     count := 0
    95.     node := list.Head.Next
    96.     for node != list.Tail {
    97.         if count == index {
    98.             return node.Val
    99.         }
    100.         count++
    101.         node = node.Next
    102.     }
    103.     return -1
    104. }
    106. func (list *List) AddAtHead(val int) {
    107.     node := &Node{
    108.         Val:  val,
    109.         Prev: list.Head,
    110.         Next: list.Head.Next,
    111.     }
    112.     list.Head.Next.Prev = node
    113.     list.Head.Next = node
    114.     list.Length++
    115. }
    117. func (list *List) AddAtTail(val int) {
    118.     node := &Node{
    119.         Val:  val,
    120.         Prev: list.Tail.Prev,
    121.         Next: list.Tail,
    122.     }
    123.     list.Tail.Prev.Next = node
    124.     list.Tail.Prev = node
    125.     list.Length++
    126. }
    128. func (list *List) AddAtIndex(index int, val int) {
    129.     if index <= 0 {
    130.         list.AddAtHead(val)
    131.         return
    132.     }
    133.     if index > list.Length {
    134.         return
    135.     }
    136.     if index == list.Length {
    137.         list.AddAtTail(val)
    138.         return
    139.     }
    140.     node := &Node{
    141.         Val:  val,
    142.         Prev: nil,
    143.         Next: nil,
    144.     }
    145.     count := 0
    146.     listNode := list.Head.Next
    147.     for listNode != list.Tail {
    148.         if count == index-1 {
    149.             node.Prev = listNode
    150.             node.Next = listNode.Next
    151.             listNode.Next.Prev = node
    152.             listNode.Next = node
    153.             list.Length++
    154.         }
    155.         listNode = listNode.Next
    156.         count++
    157.     }
    158. }
    160. func (list *List) DeleteAtIndex(index int) {
    161.     if index < 0 || index > list.Length {
    162.         return
    163.     }
    164.     count := 0
    165.     node := list.Head.Next
    166.     for node != list.Tail {
    167.         if count == index {
    168.             nodePrev := node.Prev
    169.             nodeNext := node.Next
    170.             nodePrev.Next = nodeNext
    171.             nodeNext.Prev = nodePrev
    172.             list.Length--
    173.         }
    174.         node = node.Next
    175.         count++
    176.     }
    177. }
    179. func (list *List) Show() {
    180.     node := list.Head
    181.     for node != nil {
    182.         fmt.Printf("%d -> ", node.Val)
    183.         node = node.Next
    184.     }
    185.     fmt.Println()
    186.     node = list.Head
    187.     for node != nil {
    188.         fmt.Printf("%p %v\n", node, node)
    189.         node = node.Next
    190.     }
    191. }