占卜算卦是一个古老的方法，人们无把握又希望应对未来时，经常通过这个方法获得一些确定性的心理效应。

其社会影响深远而广泛，虽然它并不是一种完全准确的科学，但我们可以通过go实现 一个简易的占卜程序，用以了解我们的古人如何处理不确定性的。 并尝试了解其中的变化规则。

本文介绍了双向链表的实现，用于存储卦象的爻信息。定义了包含number、yaobian、prev和next的node结构体，以及具有lens、head和tail的dlist结构体。

1 双向链表的实现

我们可以通过双向链表 存储卦象的6个爻，这样我们可以知道前后顺序，并且可以在每个节点存储变爻的值，为此实现其结构体 和 链表

定义链表结构体

type node struct {
        number  int    //爻值
        yaobian [][]int   //三次爻变的 具体算子
        prev    *node   //前一个爻 节点
        next    *node   //后一个爻 节点
    }

定义双向链表

type dlist struct {
        lens int
        head *node
        tail *node
    }

链表构造函数

func makeDlist() *dlist {
        return &dlist{}
    }

判断是否空链表

func (this *dlist) newNodeList(n *node) bool { 

    if this.lens == 0 {
        this.head = n
        this.tail = n
        n.prev = nil
        n.next = nil
        this.lens += 1
        return true
    } else {
        Logg.Panic("not empty node list.")
    }
    return false
}

头部添加 节点

func (this *dlist) pushHead(n *node) bool {

    if this.lens == 0 {
        return this.newNodeList(n)
    } else {
        this.head.prev = n
        n.prev = nil
        n.next = this.head
        this.head = n
        this.lens += 1
        return true
    }
}

添加尾部节点，我们主要使用此方法，用以保持爻的相对位置

func (this *dlist) append(n *node) bool {

    if this.lens == 0 {
        return this.newNodeList(n)
    } else {
        this.tail.next = n
        n.prev = this.tail
        n.next = nil
        this.tail = n
        this.lens += 1
        return true
    }
}

显示并返回链表的值

func (this *dlist) display() []int {

    numbs := []int{}
    node := this.head
    t := 0 
    for node != nil {

        Logg.Println(node.number, node.yaobian)
        numbs = append(numbs, node.number)
        t += 1
        if t >= this.lens {
            break
        }

        node = node.next
    }

    fmt.Println("length:", this.lens)
    return numbs
}

2 结语

本小节我们实现了 一个简单的双向链表，包括其链表节点 和 链表管理，添加和查询操作，这将在第三节运势解读中得到运用。