Go语言数据结构和算法-DoubleLinkedList(双向链表)

Prepend(val)    // 在双向链表的头部添加新数据
Append(val)     // 在双向链表的尾部添加新数据
Remove(val)     // 在双向链表中删除一个数据
Contains(val)   // 在双向链表中是否包含这个元素
Reverse()		// 倒序遍历双向链表
String()        // 遍历打印双向链表的所有元素

双向链表的数据结构

type Node struct {
	val  interface{}
	prev *Node
	next *Node
}

type DoubleLinkedList struct {
	head *Node
	tail *Node
	size int
}

Prepend(val) 在双向链表的头部添加新数据

func (list *DoubleLinkedList) Prepend(val interface{}) {
	node := &Node{val, nil, nil}
	if list.head == nil {
		list.head = node
		list.tail = node
	} else {
		node.next = list.head
		list.head.prev = node
		list.head = node
	}
	list.size += 1
}

Append(val) 在双向链表的尾部添加新数据

func (list *DoubleLinkedList) Append(val interface{}) {
	node := &Node{val, nil, nil}
	if list.head == nil {
		list.head = node
		list.tail = node
	} else {
		list.tail.next = node
		node.prev = list.tail
		list.tail = node
	}
	list.size += 1
}

Remove(val) 在双向链表中删除一个数据

func (list *DoubleLinkedList) Remove(val interface{}) bool {
	if list.head == nil {
		return false
	}
	if list.head.val == val {
		if list.head == list.tail {
			list.head = nil
			list.tail = nil
		} else {
			list.head = list.head.next
			list.head.prev = nil
		}
		return true
	}
	cur := list.head.next
	for cur != nil {
		if cur.val == val {
			if cur == list.tail {
				list.tail = list.tail.prev
				list.tail.next = nil
			} else {
				cur.prev.next = cur.next
				cur.next.prev = cur.prev
			}
			return true
		}
		cur = cur.next
	}
	return false
}

Contains(val) 在双向链表中是否包含这个元素

func (list *DoubleLinkedList) Contains(val interface{}) bool {
	cur := list.head
	for cur != nil {
		if cur.val == val {
			return true
		}
		cur = cur.next
	}
	return false
}

Reverse() 倒序遍历双向链表

func (list *DoubleLinkedList) Reverse() {
	cur := list.tail
	for cur != nil {
		fmt.Print(cur.val, "->")
		cur = cur.prev
	}
}

String() 遍历打印双向链表的所有元素

func (list *DoubleLinkedList) String() {
	cur := list.head
	for cur != nil {
		fmt.Print(cur.val, "->")
		cur = cur.next
	}
}

源码