双向链表实现原理

package main

import "fmt"

type linknode struct {
	data interface{} //数据
	prev *linknode   //上一个指针
	next *linknode   //下一个指针
}

//创建双向链表  （数据集合）
func (node *linknode) create(data ...interface{}) {
	if node == nil {
		return
	}
	if len(data) == 0 {
		return
	}

	//记录头节点
	head := node

	for _, v := range data {
		//创建新节点
		newnode := new(linknode)
		newnode.data = v
		//新节点指向上一个节点
		newnode.prev = node
		//当前节点的下一个节点是新节点
		node.next = newnode
		//当前节点为下一个节点
		node = node.next
	}

	//头节点的上一个节点prev 可以指向最后一个节点
	//head.prev=node
	node = head

}

//打印双向链表
func (node *linknode) print() {
	if node == nil {
		return
	}
	//正序打印数据
	for node != nil {
		if node.data != nil {
			fmt.println(node.data)
		}
		node = node.next
	}
}

//打印双向链表 倒序
func (node *linknode) print02() {
	if node == nil {
		return
	}
	//指向链表末尾
	for node.next != nil {
		node = node.next
	}
	//从后向前打印数据
	for node.prev != nil {
		if node.data != nil {
			fmt.println(node.data)
		}
		node = node.prev
	}
}

//数据长度 返回值 个数
func (node *linknode) length() int {
	if node == nil {
		return -1
	}
	i := 0
	for node.next != nil {
		i++
		node = node.next
	}
	return i
}

//插入数据 （下标 数据）
func (node *linknode) index(index int, data interface{}) {
	if node == nil {
		return
	}
	if index < 0 {
		return
	}
	if data == nil {
		return
	}

	//记录上一个节点
	prenode := node
	//循环找到插入的节点
	for i := 0; i < index; i++ {
		prenode = node
		if node == nil {
			return
		}
		node = node.next
	}

	//创建新节点
	newnode := new(linknode)
	newnode.data = data
	//将新节点的指针域分别指向上一个节点和下一个节点
	newnode.next = node
	newnode.prev = prenode

	//上一个节点的下一个节点为新节点
	prenode.next = newnode
	//下一个节点的上一个节点为新节点
	node.prev = newnode

}

//删除数据 （下标）
func (node *linknode) delete(index int) {
	if node == nil {
		return
	}
	if index < 0 {
		return
	}

	//记录上一个节点
	prenode := node
	for i := 0; i < index; i++ {
		prenode = node
		if node == nil {
			return
		}

		node = node.next
	}

	//删除节点
	// 把上一个节点的 next 变为当前节点的下一个节点
	prenode.next = node.next
	//将当前节点的下一个节点的上一个节点变为上一个节点
	//当前节点的下一个节点的上一个节点为上一个节点
	node.next.prev = prenode

	//销毁当前节点
	node.data = nil
	node.next = nil
	node.prev = nil
	node = nil
}

//链表销毁
func (node *linknode) destroy() {
	if node == nil {
		return
	}

	node.next.destroy()

	node.data = nil
	node.next = nil
	node.prev = nil
	node = nil
}