The principle singly linked list

package main

import (
	"fmt"
	"reflect"
)

// list is achieved by the present structure of the nested structure pointer
// This structure can be nested structure pointer, but this can not be nested structure itself, the length can not exceed 1024
type LinkNode struct {
	Data interface{}
	Next * LinkNode // right, this can be nested structure pointer
	// Next LinkNode // error, this can not be nested structure itself
}

// Create a list Create (data)
func (node *LinkNode) Create(Data ...interface{}) { //1,2
	if node == nil {
		return
	}
	// head node
	head := node

	for i := 0; i < len(Data); i++ {
		// Create a new node
		newNode := new(LinkNode)
		newNode.Data = Data[i]
		newNode.Next = nil
		// the new node as the next current node
		node.Next = newNode
		node = node.Next
	}
	node = head

}

// Print the list
func (node *LinkNode) Print() {
	if node == nil {
		return
	}

	// print data
	if node.Data != nil {
		fmt.Println(node.Data, " ")
	}
	// recursive traversal of the next data
	node.Next.Print()
}

// chain length
func (node *LinkNode) Length() int {
	if node == nil {
		return -1
	}

	i := 0
	// Find the first node is nil
	for node.Next != nil {
		i++
		node = node.Next
	}
	return i
}

// insert data (head plug)
func (node *LinkNode) InsertByHead(Data interface{}) {
	if node == nil {
		return
	}
	if Data == nil {
		return
	}

	//head:=node

	// Create a new node
	newNode := new(LinkNode)
	// new node assignment
	newNode.Data = Data
	newNode.Next = node.Next
	// the new node after the current node
	node.Next = newNode
}

// insert data (Tail plug)
func (node *LinkNode) InsertByTail(Data interface{}) {
	if node == nil {
		return
	}

	// find the end position in the list
	for node.Next != nil {
		node = node.Next
	}
	// Create a new node assignment
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = nil
	// the new node at the end of the list
	node.Next = newNode
}

// insert data (index) position
func (node *LinkNode) InserrByIndex(index int, Data interface{}) {
	if node == nil {
		return
	}
	if index < 0 {
		return
	}
	/*
	if node.Length() < index{
		return
	}
	*/

	// record on a node
	preNode: = node
	for i := 0; i < index; i++ {
		preNode = node
		// If the list exceeds the number of direct return
		if node == nil {
			return
		}
		node = node.Next
	}

	// Create a new node
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = node

	// node on a link to the current node
	preNode.Next = newNode

}

// delete data (index) position
func (node *LinkNode) DeleteByIndex(index int) {
	if node == nil {
		return
	}

	if index < 0 {
		return
	}
	// recorded on a list node
	preNode: = node
	for i := 0; i < index; i++ {
		preNode = node
		if node == nil {
			return
		}
		node = node.Next
	}

	// pointer to a domain node to point to the next node node
	preNode.Next = node.Next

	// destroy the current node
	node.Data = nil
	node.Next = nil
	node = nil
}

// delete data (data)
func (node *LinkNode) DeleteByData(Data interface{}) {
	if node == nil {
		return
	}
	if Data == nil {
		return
	}

	preNode: = node
	for node.Next != nil {
		preNode = node
		node = node.Next

		// interface is determined whether the same type of data stored
		//reflect.DeepEqual()
		if reflect.TypeOf(node.Data) == reflect.TypeOf(Data) && node.Data == Data {
			preNode.Next = node.Next

			// destroy data
			node.Data = nil
			node.Next = nil
			node = nil

			// If you add the first return means to delete the same data
			// If you do not remove all add return the same data
			return
		}

	}
}

// Find the data (data)
func (node *LinkNode) Search(Data interface{}) int {
	if node == nil {
		return -1
	}
	if Data == nil {
		return -1
	}

	i := 0
	for node.Next != nil {
		i++
		// compare the contents of two interfaces are the same
		//reflect.DeepEqual()
		if reflect.TypeOf(node.Data) == reflect.TypeOf(Data) && node.Data == Data {
			return i - 1
		}
		node = node.Next
	}
	return -1
}

// destroy the list
func (node *LinkNode) Destroy() {
	if node == nil {
		return
	}
	// destroy the list by recursively destroyed
	node.Next.Destroy()

	node.Data = nil
	node.Next = nil
	node = nil
}