Opération de base d'une liste chaînée simple dans la syntaxe go

package main

import "fmt"

type LinkNode struct {
    
    
	val  int64
	next *LinkNode
}

func display(head *LinkNode) {
    
    
	cur := head
	for {
    
    
		if cur == nil {
    
    
			break
		} else {
    
    
			print(cur.val, " ")
			cur = cur.next
		}
	}
	print("\n")
}
func NewLinkNode(val int64) *LinkNode {
    
    
	//tmp := new(LinkNode)
	//tmp.val = val
	//tmp.next = nil
	//return tmp
	return &LinkNode{
    
    val: val, next: nil}
}
func headCreateLinkList(arr []int64) *LinkNode {
    
    
	head := NewLinkNode(-1)
	for _, v := range arr {
    
    
		tmp := NewLinkNode(v)
		tmp.next = head.next
		head.next = tmp
	}
	return head
}
func tailCreateLinkList(arr []int64) *LinkNode {
    
    
	head := NewLinkNode(-1)
	p := head
	for _, value := range arr {
    
    
		tmp := NewLinkNode(value)
		p.next = tmp
		p = tmp
	}
	return head
}
func getArr() []int64 {
    
    
	arr := []int64{
    
    }
	var num int64
	for {
    
    
		ret, _ := fmt.Scan(&num)
		if ret == 0 {
    
    
			break
		}
		slice := append(arr, num)
		slice, arr = arr, slice
	}
	return arr
}
func insertHeadNode(head *LinkNode, val int64) *LinkNode {
    
    
	tmp := NewLinkNode(val)
	tmp.next = head.next
	head.next = tmp
	return head.next
}
func insertTailNode(head *LinkNode, val int64) *LinkNode {
    
    
	tmp := NewLinkNode(val)
	cur := head.next
	for ; cur.next != nil; cur = cur.next {
    
    
	}
	cur.next = tmp
	cur = tmp
	return cur
}
func insertIndexNode(head *LinkNode, index int64, val int64) *LinkNode {
    
    
	if index > getListLength(head)+1 || index < 1 {
    
    
		print("index 参数不合法")
		return nil
	}
	if index == 1 {
    
    
		return insertHeadNode(head, val)
	}
	var i int64 = 1
	var ret *LinkNode = nil
	for cur := head.next; cur != nil; cur = cur.next {
    
    
		println(i)
		if i == index {
    
    
			tmp := NewLinkNode(val)
			cur.val, tmp.val = tmp.val, cur.val
			tmp.next = cur.next
			cur.next = tmp
			ret = cur
			break
		} else {
    
    
			i++
		}
	}
	if ret == nil {
    
    
		return insertTailNode(head, val)
	}
	return ret
}
func getListLength(head *LinkNode) int64 {
    
    
	var length int64 = 0
	for cur := head.next; cur != nil; cur = cur.next {
    
    
		length++
	}
	return length
}
func deleteIndexNode(head *LinkNode, index int64) *LinkNode {
    
    
	var i int64 = 1
	var ret *LinkNode = nil
	for cur := head.next; cur != nil; cur = cur.next {
    
    
		if i == index {
    
    
			if cur.next != nil {
    
    
				cur.val, cur.next.val = cur.next.val, cur.val
				cur.next = cur.next.next
				ret = cur
				break
			} else {
    
    
				cur = nil
			}
		}
		i++
	}
	return ret
}
func main() {
    
    
	head := tailCreateLinkList(getArr())
	display(head)
	//deleteIndexNode(head, 3)
	//fmt.Print(ret.val)
	insertIndexNode(head, 2, 200)
	display(head)
}