單向鏈表實現原理

package main

import (
	"fmt"
	"reflect"
)

//經過結構體嵌套本結構體指針來實現鏈表
//結構體能夠嵌套本結構體指針, 但不能嵌套本結構體自己, 長度不能超過 1024
type LinkNode struct {
	Data interface{}
	Next *LinkNode // right , 能夠嵌套本結構體指針
	//Next LinkNode // error, 不能嵌套本結構體自己
}

//建立鏈表 Create(數據)
func (node *LinkNode) Create(Data ...interface{}) { //1,2
	if node == nil {
		return
	}
	//頭節點
	head := node

	for i := 0; i < len(Data); i++ {
		//建立一個新的節點
		newNode := new(LinkNode)
		newNode.Data = Data[i]
		newNode.Next = nil
		//將新節點做爲當前節點的下一個節點
		node.Next = newNode
		node = node.Next
	}
	node = head

}

//打印鏈表
func (node *LinkNode) Print() {
	if node == nil {
		return
	}

	//打印數據
	if node.Data != nil {
		fmt.Println(node.Data, " ")
	}
	//使用遞歸遍歷下一個數據
	node.Next.Print()
}

//鏈表長度
func (node *LinkNode) Length() int {
	if node == nil {
		return -1
	}

	i := 0
	//一次查找下一個節點是否爲nil
	for node.Next != nil {
		i++
		node = node.Next
	}
	return i
}

//插入數據（頭插）
func (node *LinkNode) InsertByHead(Data interface{}) {
	if node == nil {
		return
	}
	if Data == nil {
		return
	}

	//head:=node

	//建立新節點
	newNode := new(LinkNode)
	//新節點賦值
	newNode.Data = Data
	newNode.Next = node.Next
	//將新節點放在當前節點後面
	node.Next = newNode
}

//插入數據（尾插）
func (node *LinkNode) InsertByTail(Data interface{}) {
	if node == nil {
		return
	}

	//查找鏈表的末尾位置
	for node.Next != nil {
		node = node.Next
	}
	//建立新節點  賦值
	newNode := new(LinkNode)
	newNode.Data = Data
	newNode.Next = nil
	//將新節點放在鏈表末尾
	node.Next = newNode
}

//插入數據（下標）位置
func (node *LinkNode) InserrByIndex(index int, Data interface{}) {
	if node == nil {
		return
	}
	if index < 0 {
		return
	}
	/*
	if node.Length() < index{
		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

	//上一個節點連接當前節點
	preNode.Next = newNode

}

//刪除數據（下標）位置
func (node *LinkNode) DeleteByIndex(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
	}

	//將上一個指針域結點指向node的下一個節點
	preNode.Next = node.Next

	//銷燬當前節點
	node.Data = nil
	node.Next = nil
	node = nil
}

//刪除數據（數據）
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存儲的數據類型是否相同
		//reflect.DeepEqual()
		if reflect.TypeOf(node.Data) == reflect.TypeOf(Data) && node.Data == Data {
			preNode.Next = node.Next

			//銷燬數據
			node.Data = nil
			node.Next = nil
			node = nil

			//若是添加return 表示刪除第一個相同的數據
			//若是不添加return 表示刪除全部相同的數據
			return
		}

	}
}

//查找數據 （數據）
func (node *LinkNode) Search(Data interface{}) int {
	if node == nil {
		return -1
	}
	if Data == nil {
		return -1
	}

	i := 0
	for node.Next != nil {
		i++
		//比較兩個接口中的內容是否相同
		//reflect.DeepEqual()
		if reflect.TypeOf(node.Data) == reflect.TypeOf(Data) && node.Data == Data {
			return i - 1
		}
		node = node.Next
	}
	return -1
}

//銷燬鏈表
func (node *LinkNode) Destroy() {
	if node == nil {
		return
	}
	//經過遞歸毀銷燬鏈表
	node.Next.Destroy()

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