Go语言双向链表实现中的nil指针恐慌与正确初始化指南

func (A *DoublyLinkedList) AddHead(input_value interface{}) {
  temp_node := &Node{value: input_value, prev: nil, next: A.head} // A.head 此时可能为 nil
  original_head_node := A.head                                   // original_head_node 此时为 nil
  original_head_node.prev = temp_node                            // 尝试对 nil.prev 赋值，导致 panic
  A.length++
}

// 假设 target_node.GetPrevNode() 返回 nil
// 尝试执行 target_node.GetPrevNode().GetNextNode() = some_node
// 同样会导致对 nil 进行解引用，从而引发 panic。

// Node 定义双向链表的节点
type Node struct {
    value interface{}
    prev  *Node
    next  *Node
}

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

// NewNode 创建一个新节点
func NewNode(value interface{}, prev, next *Node) *Node {
    return &Node{
        value: value,
        prev:  prev,
        next:  next,
    }
}

// NewDoublyLinkedList 创建并返回一个空的双向链表
func NewDoublyLinkedList() *DoublyLinkedList {
    return &DoublyLinkedList{
        head:   nil, // 初始时 head 为 nil
        tail:   nil, // 初始时 tail 为 nil
        length: 0,
    }
}

// AddHead 在链表头部添加一个新元素
func (A *DoublyLinkedList) AddHead(input_value interface{}) {
    newNode := NewNode(input_value, nil, nil) // 创建新节点，初始 prev 和 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++
}

package main

import "fmt"

// Node 定义双向链表的节点
type Node struct {
    value interface{}
    prev  *Node
    next  *Node
}

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

// NewNode 创建一个新节点
func NewNode(value interface{}, prev, next *Node) *Node {
    return &Node{
        value: value,
        prev:  prev,
        next:  next,
    }
}

// NewDoublyLinkedList 创建并返回一个空的双向链表
func NewDoublyLinkedList() *DoublyLinkedList {
    return &DoublyLinkedList{
        head:   nil,
        tail:   nil,
        length: 0,
    }
}

// AddHead 在链表头部添加一个新元素
func (A *DoublyLinkedList) AddHead(input_value interface{}) {
    newNode := NewNode(input_value, nil, nil) // 创建新节点，初始 prev 和 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++
}

// DisplayList 从头到尾打印链表元素
func (A *DoublyLinkedList) DisplayList() {
    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()
}

// DisplayListReverse 从尾到头打印链表元素
func (A *DoublyLinkedList) DisplayListReverse() {
    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() {
    myList := NewDoublyLinkedList()
    fmt.Println("Initial list length:", myList.length) // 0

    myList.AddHead(10) // 链表: 10
    myList.DisplayList() // List (head to tail): 10
    myList.DisplayListReverse() // List (tail to head): 10
    fmt.Println("List length after AddHead(10):", myList.length) // 1

    myList.AddHead(20) // 链表: 20 -> 10
    myList.DisplayList() // List (head to tail): 20 10
    myList.DisplayListReverse() // List (tail to head): 10 20
    fmt.Println("List length after AddHead(20):", myList.length) // 2

    myList.AddHead(30) // 链表: 30 -> 20 -> 10
    myList.DisplayList() // List (head to tail): 30 20 10
    myList.DisplayListReverse() // List (tail to head): 10 20 30
    fmt.Println("List length after AddHead(30):", myList.length) // 3

    // 验证头尾指针
    if myList.head != nil {
        fmt.Printf("Head value: %v, Head.prev: %v\n", myList.head.value, myList.head.prev) // Head.prev 应该为 nil
    }
    if myList.tail != nil {
        fmt.Printf("Tail value: %v, Tail.next: %v\n", myList.tail.value, myList.tail.next) // Tail.next 应该为 nil
    }
}