Go 简单实现双向链表

// 双向链表结点存储对象
type DoubleLinkObj interface{}

// 双向链表结点
type DoubleLinkNode struct {
	Value DoubleLinkObj // 当前结点对象

	Prov *DoubleLinkNode // 上一结点
	Next *DoubleLinkNode // 下个结点
}

// 双向链表
type DoubleLink struct {
	// TODO 如果链表的读写操作是多线程操作的，那么就需要加锁了
	FirstNode *DoubleLinkNode // 第一个结点
	LastNode  *DoubleLinkNode // 最后一个结点
	Len       int             // 链表长度
}

// 初始化
func (Self *DoubleLink) Init() {
	Self.FirstNode = nil
	Self.LastNode = nil
	Self.Len = 0
}

// 添加结点
func (Self *DoubleLink) AddNode(aObj DoubleLinkObj) bool {
	if aObj == nil {
		return false
	}

	// 创建一个新的结点
	mNode := &DoubleLinkNode{
		Value: aObj,
		Prov:  nil,
		Next:  nil,
	}

	// 如果当前链表首个结点 == nil，当前添加的这个结点就是首个结点
	if Self.FirstNode == nil {
		Self.FirstNode = mNode
	}

	// 如果最后一个结点 != nil 就需要修改之前最后结点的指向，以及当前添加指针的上一个指向
	if Self.LastNode != nil {
		// 否则就将之前最后一个结点的下个结点指针指向当前添加的结点
		Self.LastNode.Next = mNode
		// 同时将当前添加的结点的上一个结点指针指向 当前的最后结点
		mNode.Prov = Self.LastNode
	}

	// 此时最后最后一个结点的指针需要替换成为当前添加的指针
	Self.LastNode = mNode
	Self.Len++
	return true
}

// 删除结点
func (Self *DoubleLink) DelNode(aObj DoubleLinkObj) bool {
	if aObj == nil {
		return false
	}

	mNode := Self.FirstNode
	for mNode != nil {
		// 如果这个结点的值 == 需要删除的值
		if mNode.Value == aObj {
			Self.Len--

			// 将其上个结点的Next的指向改为当前删除的的下一个指针
			mTempNode := mNode.Prov
			if mTempNode != nil {
				mTempNode.Next = mNode.Next
			} else {
				// 如果上一个结点是空的，那就说明这个结点是首个结点
				// 链表的FirstNode数据是需要发生变化的

				// 如果当前链表长度 == 0
				if Self.Len == 0 {
					Self.FirstNode = nil
				} else {
					Self.FirstNode = mNode.Next
				}
			}

			// 将其下个结点的 Prov 的指向改为当前删除的的上一个指针
			mTempNode = mNode.Next
			if mTempNode != nil {
				mTempNode.Prov = mNode.Prov
			} else {
				// 如果下一个结点是空的，那就说明这个结点是尾结点
				// 链表的LastNode数据是需要发生变化的

				// 如果当前链表长度 == 0
				if Self.Len == 0 {
					Self.LastNode = nil
				} else {
					Self.LastNode = mNode.Prov
				}
			}

			return true
		}

		mNode = mNode.Next
	}

	return true
}

// 查找结点
func (Self *DoubleLink) FindNode(aObj DoubleLinkObj) *DoubleLinkNode {
	if aObj == nil {
		return nil
	}

	mNode := Self.FirstNode
	for mNode != nil {
		// 如果这个结点的值 == 需要删除的值
		if mNode.Value == aObj {
			return mNode
		}
	}

	return nil
}

// 打印链表
func (Self *DoubleLink) PrintDoubleLink() {
	mNode := Self.FirstNode
	if mNode == nil {
		fmt.Println("当前链表为空")
		return
	}

	fmt.Println("当前链表长度 =", Self.Len)
	fmt.Println("当前链表FirstNode =", *Self.FirstNode)
	fmt.Println("当前链表Last =", *Self.LastNode)
	mCnt := 1
	for mNode != nil {
		fmt.Println("第", mCnt, "个结点=", mNode.Value)
		mNode = mNode.Next
		mCnt++
	}
}

测试使用：

func TestDoubleLink(t *testing.T) {
	mDoubleLink := DoubleLink{}
	mDoubleLink.Init()

	mDoubleLink.PrintDoubleLink()

	mDoubleLink.AddNode("小印01")
	mDoubleLink.AddNode("小印02")
	mDoubleLink.AddNode("小印03")
	mDoubleLink.AddNode("小印04")
	mDoubleLink.AddNode("小印05")
	mDoubleLink.AddNode(6666)

	mDoubleLink.PrintDoubleLink()

	mDoubleLink.DelNode("小印01")
	mDoubleLink.DelNode("小印03")
	mDoubleLink.DelNode(6666)

	mDoubleLink.PrintDoubleLink()

	mTempNode := mDoubleLink.FindNode("小印01")
	if mTempNode != nil {
		fmt.Println("查找到了", mTempNode.Value)
	}
}

一点点笔记，以便以后翻阅。