前言

提示：Go语言和C语言有很多类似的地方，有C的基础学Go能非常快上手，会C++会更快：

单链表的操作有创建一个链表通过数组，遍历单链表，尾部插入，指定位置插入，删除指定位置的元素，查找指定的节点等。

一、个人见解，为什么学GO？

博主是在某个厂里面实习，所以打算开拓第二语言，我第一门语言是Java，学习GO主要是因为兴趣或者说想更深入底层。如果你也想增加一门新语言，GO或Python都行，看个人选择和方向。

二、Go语言实现单链表

1.创建节点

代码如下（示例）：

package main
import "fmt"
//单链表
type Node struct {
	//数据域
	Data int
	//指针域
	Next *Node
}

2.通过数组创建一个单链表

代码如下（示例）：

//创建一个链表通过数组, 首字母小写表示private
func createLikedList(arr []int) *Node {
	//创建头指针
	head := Node{}
	//临时指针
	p := &head
	//循环遍历，_表示跳过接收该参数
	for _, v := range arr {
		//创建新的节点
		node := Node{Data: v, Next: nil}
		p.Next = &node
		p = p.Next
	}
	return &head
}

注意的是Go语言返回值是写在后面的，并且GO语言是可以返回临时变量的，与C++不同。

3.遍历单链表

//遍历单链表
func (node Node) printLikedList() {
	p := &node
	for ; p != nil; p = p.Next {
		fmt.Print(p.Data, "->")
	}
	//换行
	fmt.Println()
}

4.单链表插入操作

4.1 伪代码

在这里插入图片描述 ### 4.2尾部插入

//插入操作 -> 尾部插入
func (node *Node) tailInsert(element Node) {
	if node == nil {
		fmt.Println("Node is empty, Not Get Value....")
		return
	}
	//设置临时指针, 找到最后一个节点
	p := node
	for ; p.Next != nil; p = p.Next {
	}
	//将数据插入到末尾
	p.Next = &element
}

4.3 指定位置插入

//插入操作 -> 指定位置插入
func (node *Node) insertByIndex(index int, element Node) bool {
	if node == nil {
		fmt.Println("node is nil, please you notice....")
		return false
	}
	//设置临时指针
	p := node
	q := &element
	//计数器
	count := 0
	for ; p != nil; p = p.Next {
		//如果index等于count, 就需要插入
		if count == index {
			q.Next = p.Next
			p.Next = q
			//停止循环
			return true
		}
		count++
	}
	if index > count {
		fmt.Println("index out of range.....")
	}
	return false
}

5.删除操作

5.1 伪代码

在这里插入图片描述

5.2 代码实现

//删除操作 -> 删除指定位置的元素
func (node *Node) deleteByIndex(index int) bool {
	if node == nil || index < 0 {
		fmt.Println("node is nil or index < 0, please you notice....")
		return false
	}
	//计数器
	count := 0
	//临时指针
	p := node
	for ; p != nil; p = p.Next {
		//查找index位置的元素
		if count == index {
			p.Next = p.Next.Next
			return true
		}
		count++
	}
	if count < index {
		fmt.Println("index out of range.....")
	}
	return false
}

5.查找操作

//查找操作 -> 查找指定的节点
func (node *Node) findElementByValue(value int) (int, bool) {
	//创建一个临时节点
	p := node
	count := 0
	for ; p != nil; p = p.Next {
		if value == p.Data {
			return count - 1, true
		}
		count++
	}
	return -1, false
}

6.最终的代码

package main

import "fmt"

//单链表
type Node struct {
	//数据域
	Data int
	//指针域
	Next *Node
}

//创建一个链表通过数组
func createLikedList(arr []int) *Node {
	//创建头指针
	head := Node{}
	//临时指针
	p := &head
	//循环遍历
	for _, v := range arr {
		//创建新的节点
		node := Node{Data: v, Next: nil}
		p.Next = &node
		p = p.Next
	}
	return &head
}

//遍历单链表
func (node Node) printLikedList() {
	p := &node
	for ; p != nil; p = p.Next {
		fmt.Print(p.Data, "->")
	}
	//换行
	fmt.Println()
}

//插入操作 -> 尾部插入
func (node *Node) tailInsert(element Node) {
	if node == nil {
		fmt.Println("Node is empty, Not Get Value....")
		return
	}
	//设置临时指针, 找到最后一个节点
	p := node
	for ; p.Next != nil; p = p.Next {
	}
	//将数据插入到末尾
	p.Next = &element
}

//插入操作 -> 指定位置插入
func (node *Node) insertByIndex(index int, element Node) bool {
	if node == nil {
		fmt.Println("node is nil, please you notice....")
		return false
	}
	//设置临时指针
	p := node
	q := &element
	//计数器
	count := 0
	for ; p != nil; p = p.Next {
		//如果index等于count, 就需要插入
		if count == index {
			q.Next = p.Next
			p.Next = q
			//停止循环
			return true
		}
		count++
	}
	if index > count {
		fmt.Println("index out of range.....")
	}
	return false
}

//删除操作 -> 删除指定位置的元素
func (node *Node) deleteByIndex(index int) bool {
	if node == nil || index < 0 {
		fmt.Println("node is nil or index < 0, please you notice....")
		return false
	}
	//计数器
	count := 0
	//临时指针
	p := node
	for ; p != nil; p = p.Next {
		//查找index位置的元素
		if count == index {
			p.Next = p.Next.Next
			return true
		}
		count++
	}
	if count < index {
		fmt.Println("index out of range.....")
	}
	return false
}

//查找操作 -> 查找指定的节点
func (node *Node) findElementByValue(value int) (int, bool) {
	//创建一个临时节点
	p := node
	count := 0
	for ; p != nil; p = p.Next {
		if value == p.Data {
			return count - 1, true
		}
		count++
	}
	return -1, false
}

func main() {
	fmt.Println(">>>> 单链表 SRART <<<<")
	//创建一个数组
	arr := [...]int{1, 3, 2, 7, 9}
	//传递切片过去, 因为数组是值传递, 切片是引用传递
	root := createLikedList(arr[:])
	root.printLikedList()
	//尾部插入元素
	root.tailInsert(Node{17, nil})
	root.printLikedList()
	//指定位置插入元素
	root.insertByIndex(10, Node{10, nil})
	root.printLikedList()
	//根据指定的位置删除元素
	root.deleteByIndex(0)
	//按照顺序遍历
	root.printLikedList()
	//查找特定元素
	fmt.Println(root.findElementByValue(2))
	fmt.Println(">>>> 单链表 END <<<<")
}