golang数据结构和算法之DoublyLinkedList双向链表

双向链表比起单向链表，

多了一个向前指向的指针，

所以在增删查改时，要同时照顾到两个指针的指向。

DoublyLinkedList.go

package DoublyLinkedList

//双向链表
type Node struct {
	data int
	next *Node
	prev *Node
}

type DoublyLinkedList struct {
	head *Node
	tail *Node
}

func (list *DoublyLinkedList) InsertFirst(i int) {
	data := &Node{data: i}
	if list.head != nil {
		list.head.prev = data
		data.next = list.head
	}
	list.head = data
}

func (list *DoublyLinkedList) InsertLast(i int) {
	data := &Node{data: i}
	if list.head == nil {
		list.head = data
		list.tail = data
		return
	}
	if list.tail != nil {
		list.tail.next = data
		data.prev = list.tail
	}
	list.tail = data
}

func (list *DoublyLinkedList) RemoveByValue(i int) bool {
	if list.head == nil {
		return false
	}

	if list.head.data == i {
		list.head = list.head.next
		list.head.prev = nil
		return true
	}
	if list.tail.data == i {
		list.tail = list.tail.prev
		list.tail.next = nil
		return true
	}
	current := list.head
	for current.next != nil {
		if current.next.data == i {
			if current.next.next != nil {
				current.next.next.prev = current
			}
			current.next = current.next.next
			return true
		}
		current = current.next
	}
	return false
}

func (list *DoublyLinkedList) RemoveByIndex(i int) bool {
	if list.head == nil {
		return false
	}
	if i < 0 {
		return false
	}

	if i == 0 {
		list.head.prev = nil
		list.head = list.head.next
		return true
	}
	current := list.head
	for u := 1; u < i; u++ {
		if current.next.next == nil {
			return false
		}
		current = current.next
	}
	if current.next.next != nil {
		current.next.next.prev = current
	}
	current.next = current.next.next
	return true
}

func (list *DoublyLinkedList) SearchValue(i int) bool {
	if list.head == nil {
		return false
	}
	current := list.head
	for current != nil {
		if current.data == i {
			return true
		}
		current = current.next
	}
	return false
}

func (list *DoublyLinkedList) GetFirst() (int, bool) {
	if list.head == nil {
		return 0, false
	}
	return list.head.data, true
}

func (list *DoublyLinkedList) GetLast() (int, bool) {
	if list.head == nil {
		return 0, false
	}
	current := list.head
	for current.next != nil {
		current = current.next
	}
	return current.data, true
}

func (list *DoublyLinkedList) GetSize() int {
	count := 0
	current := list.head
	for current != nil {
		count += 1
		current = current.next
	}
	return count
}

func (list *DoublyLinkedList) GetItemFromStart() []int {
	var items []int
	current := list.head
	for current != nil {
		items = append(items, current.data)
		current = current.next
	}
	return items
}

func (list *DoublyLinkedList) GetItemFromEnd() []int {
	var items []int
	current := list.tail
	for current != nil {
		items = append(items, current.data)
		current = current.prev
	}
	return items
}

　　

DoublyLinkedList_test.go

package DoublyLinkedList

//使用随机数作测试
import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

func TestDoublyLinkedList(t *testing.T) {

	random := rand.New(rand.NewSource(time.Now().UnixNano()))
	headNode := &Node{
		data: random.Intn(100),
		next: nil,
		prev: nil,
	}
	list := &DoublyLinkedList{
		head: headNode,
		tail: headNode,
	}

	fmt.Println(list.GetItemFromStart())
	list.InsertFirst(random.Intn(100))
	fmt.Println(list.GetItemFromStart())
	list.InsertLast(random.Intn(100))
	fmt.Println(list.GetItemFromStart())
	randNumber := random.Intn(100)
	list.InsertFirst(randNumber)
	fmt.Println(list.GetItemFromStart())
	list.InsertLast(random.Intn(100))
	fmt.Println(list.GetItemFromStart())
	list.InsertFirst(random.Intn(100))
	fmt.Println(list.GetItemFromStart())
	fmt.Println(list.GetItemFromEnd())

	if list.SearchValue(randNumber) == false {
		t.Fail()
	}
	list.RemoveByValue(randNumber)
	if list.SearchValue(randNumber) == true {
		t.Fail()
	}
	fmt.Println(list.GetFirst())
	fmt.Println(list.GetLast())
	fmt.Println(list.GetSize())

}