Go语言双向链表实现：避免nil指针恐慌的正确姿势

package main

import "fmt"

// Node 定义双向链表中的一个节点
type Node struct {
    value interface{} // 节点存储的值，使用interface{}支持任意类型
    prev  *Node       // 指向前一个节点的指针
    next  *Node       // 指向后一个节点的指针
}

// DoublyLinkedList 定义双向链表结构
type DoublyLinkedList struct {
    head   *Node // 链表的头节点
    tail   *Node // 链表的尾节点
    length int   // 链表的长度
}

// 错误的AddHead实现示例
func (A *DoublyLinkedList) AddHead(input_value interface{}) {
  temp_node := &Node{value: input_value, prev: nil, next: A.head}
  original_head_node := A.head // 当链表为空时，A.head为nil
  original_head_node.prev = temp_node // 此时original_head_node为nil，尝试访问其prev字段会导致panic
  A.length++
}

// 另一种可能导致逻辑错误的AddHead实现示例
func (A *DoublyLinkedList) AddHead(input_value interface{}) {
   // 假设NewNode只设置了新节点的next指针，而未更新旧头节点的prev指针
   A.head = &Node{value: input_value, prev: nil, next: A.head}
   A.length++
}

// NewDoublyLinkedList 是一个构造函数，用于初始化一个空的双向链表
func NewDoublyLinkedList() *DoublyLinkedList {
    return &DoublyLinkedList{} // head, tail 默认为 nil，length 默认为 0
}

// AddHead 在链表头部添加一个新元素
func (A *DoublyLinkedList) AddHead(input_value interface{}) {
    newNode := &Node{value: input_value, prev: nil, next: nil}

    if A.head == nil {
        // 情况1: 链表为空
        // 新节点既是头节点也是尾节点
        A.head = newNode
        A.tail = newNode
    } else {
        // 情况2: 链表非空
        // 新节点的next指向当前的头节点
        newNode.next = A.head
        // 当前头节点的prev指向新节点
        A.head.prev = newNode
        // 更新链表的头节点为新节点
        A.head = newNode
    }
    A.length++ // 链表长度增加
}

// PrintList 打印链表内容，用于验证
func (A *DoublyLinkedList) PrintList() {
    current := A.head
    fmt.Print("List: ")
    for current != nil {
        fmt.Printf("%v <-> ", current.value)
        current = current.next
    }
    fmt.Printf("nil (Length: %d)\n", A.length)
}

func main() {
    fmt.Println("--- 初始化双向链表 ---")
    list := NewDoublyLinkedList()
    list.PrintList() // Output: List: nil (Length: 0)

    fmt.Println("\n--- 添加元素 3 到头部 ---")
    list.AddHead(3)
    list.PrintList() // Output: List: 3 <-> nil (Length: 1)
    // 验证头尾指针
    if list.head != nil && list.tail != nil {
        fmt.Printf("Head: %v, Tail: %v\n", list.head.value, list.tail.value)
    }

    fmt.Println("\n--- 添加元素 2 到头部 ---")
    list.AddHead(2)
    list.PrintList() // Output: List: 2 <-> 3 <-> nil (Length: 2)
    // 验证头尾指针及双向连接
    if list.head != nil && list.head.next != nil {
        fmt.Printf("Head: %v, Head.Next: %v, Head.Next.Prev: %v\n", list.head.value, list.head.next.value, list.head.next.prev.value)
    }

    fmt.Println("\n--- 添加元素 1 到头部 ---")
    list.AddHead(1)
    list.PrintList() // Output: List: 1 <-> 2 <-> 3 <-> nil (Length: 3)
    // 再次验证头尾指针及双向连接
    if list.head != nil && list.head.next != nil && list.head.next.next != nil {
        fmt.Printf("Head: %v, Head.Next: %v, Head.Next.Next: %v, Tail: %v\n", list.head.value, list.head.next.value, list.head.next.next.value, list.tail.value)
        fmt.Printf("Node 2 (value %v) Prev: %v, Next: %v\n", list.head.next.value, list.head.next.prev.value, list.head.next.next.value)
    }
}