解决Go双向链表实现中的Nil指针恐慌：深度教程

// Node 表示双向链表中的一个节点
type Node struct {
    value interface{} // 存储节点数据，使用 interface{} 以支持任意类型
    prev  *Node       // 指向前一个节点的指针
    next  *Node       // 指向下一个节点的指针
}

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

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 // 尝试对 nil 解引用，导致恐慌！
    A.length++
}

// NewDoublyLinkedList 创建并返回一个新的空双向链表
func NewDoublyLinkedList() *DoublyLinkedList {
    return &DoublyLinkedList{
        head:   nil, // 默认就是 nil，但显式写出更清晰
        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: 链表非空
        newNode.next = A.head     // 新节点的下一个是当前的头节点
        A.head.prev = newNode     // 当前头节点的前一个是新节点
        A.head = newNode          // 更新链表的头节点为新节点
    }
    A.length++ // 链表长度增加
}

package main

import "fmt"

// Node 表示双向链表中的一个节点
type Node struct {
    value interface{}
    prev  *Node
    next  *Node
}

// DoublyLinkedList 表示双向链表结构
type DoublyLinkedList struct {
    head   *Node
    tail   *Node
    length int
}

// NewDoublyLinkedList 创建并返回一个新的空双向链表
func NewDoublyLinkedList() *DoublyLinkedList {
    return &DoublyLinkedList{
        head:   nil,
        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 { // 链表为空时，新节点既是头也是尾
        A.head = newNode
        A.tail = newNode
    } else { // 链表非空时
        newNode.next = A.head     // 新节点的下一个是当前的头节点
        A.head.prev = newNode     // 当前头节点的前一个是新节点
        A.head = newNode          // 更新链表的头节点为新节点
    }
    A.length++
}

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

    if A.tail == nil { // 链表为空时，新节点既是头也是尾
        A.head = newNode
        A.tail = newNode
    } else { // 链表非空时
        newNode.prev = A.tail     // 新节点的前一个是当前的尾节点
        A.tail.next = newNode     // 当前尾节点的下一个是新节点
        A.tail = newNode          // 更新链表的尾节点为新节点
    }
    A.length++
}

// Display 从头到尾打印链表元素
func (A *DoublyLinkedList) Display() {
    if A.head == nil {
        fmt.Println("List is empty")
        return
    }
    current := A.head
    fmt.Print("List (Head to Tail): ")
    for current != nil {
        fmt.Printf("%v ", current.value)
        current = current.next
    }
    fmt.Println()
}

// DisplayReverse 从尾到头打印链表元素
func (A *DoublyLinkedList) DisplayReverse() {
    if A.tail == nil {
        fmt.Println("List is empty")
        return
    }
    current := A.tail
    fmt.Print("List (Tail to Head): ")
    for current != nil {
        fmt.Printf("%v ", current.value)
        current = current.prev
    }
    fmt.Println()
}

func main() {
    list := NewDoublyLinkedList()
    fmt.Println("--- 添加元素到头部 ---")
    list.AddHead(3)
    list.AddHead(2)
    list.AddHead(1)
    list.Display()         // 预期输出: 1 2 3
    list.DisplayReverse()  // 预期输出: 3 2 1

    fmt.Println("\n--- 添加元素到尾部 ---")
    list = NewDoublyLinkedList() // 重置链表
    list.AddTail(10)
    list.AddTail(20)
    list.AddTail(30)
    list.Display()         // 预期输出: 10 20 30
    list.DisplayReverse()  // 预期输出: 30 20 10

    fmt.Println("\n--- 混合添加操作 ---")
    list = NewDoublyLinkedList()
    list.AddHead("B")
    list.AddTail("C")
    list.AddHead("A")
    list.AddTail("D")
    list.Display()         // 预期输出: A B C D
    list.DisplayReverse()  // 预期输出: D C B A
}