golang实现单链表

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

package main

import (
	"fmt"
)

type Node struct {
	Value int
	Next *Node
}

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

func (l *List) Length() int {
	cnt := 0 
	node := l.head
	for node != nil {
		cnt ++
		node = node.Next
	}
	return cnt
}

func (l *List) Append(v *Node) bool {
	if v == nil {
		return false
	}
	
	if l.size == 0 {
		l.head = v
		l.tail = v
		l.size += 1
		return true
	}

	l.tail.Next = v
	l.tail = v
	l.size += 1
	return true	
}

func (l *List) Insert(index int, v *Node) bool {
	if v == nil || index > l.size {
		return false
	}

	if index == 0 {
		v.Next = l.head
		l.head = v
		if l.size == 1{
            l.tail = v
        }
		l.size += 1
		return true
	}

	ptr := l.head
	for i := 1; i < index; i++ {
		ptr = ptr.Next
	}
	v.Next = ptr.Next
	ptr.Next = v
	if l.size == index {
		l.tail = v
	}
	l.size += 1
	return true
}

func (l *List) Delete(index int) (*Node, bool) {
	if index >= l.size {
		return nil, false
	}

	if index == 0 {
		head := l.head
		l.head = head.Next
		if l.size == 1{
            l.tail = nil
        }
		l.size-=1
		return head, true
	}

	ptr := l.head
	for i := 1; i < index; i++ {
		ptr = ptr.Next
	}
	next := ptr.Next
	ptr.Next = next.Next
	if l.size == index{
		l.tail = ptr
	}
	l.size -= 1

	return next, true
}

func (l *List) Display() {
	if l == nil {
		return
	}
	ptr := l.head 

	i := 1
	for ptr != nil {
		fmt.Println("i :", i, " value: ", ptr.Value)
		ptr = ptr.Next
		i++
	}
}

func New(nums []int) *List{
	l := &List{
		size: 0,
	}
	for _, v := range nums {
		l.Append(&Node{
			Value: v,
		})
	}
	return l
}

func main()  {
	list := New([]int{1, 2, 3, 5})
	list.Display()
	_ = list.Insert(2, &Node{
		Value: 10,
	})
	_ = list.Insert(5, &Node{
		Value: 11,
	})
	list.Display()
	_, _ = list.Delete(6)
	list.Display()
}