文章目录
1. 链表
它的存储特点为:可以用任意一组存储单元来存储单链表中的数据元素(存储单元可以是不连续的),而且,除了存储每个数据元素ai外,还必须存储指示其直接后继元素的信息。这两部分信息组成的数据元素ai的存储映像称为结点。N个结点链在一块被称为链表,当结点只包含其后继结点信息的链表就被称为单链表,而链表的第一个结点通常被称为头结点，对于单链表,又可以将其分为有头结点的单链表和无头结点的单链表.当节点既包含其后继节点信息，也包含前驱节点信息的链表被称为双链表。
2. 单链表
2.1 带头结点的单链表
在单链表的开始节点之前附设一个类型相同的节点，称为头结点。头结点的数据域可以不存储任何信息(也可以存放如线性表的长度等附加信息)，头结点的指针域存储指向开始节点的指针(即第一个元素节点的存储位置)：
优点：
-
对于带头结点的链表,当在链表的任何结点之前插入新结点或删除链表中任何结点时,所要做的都是修改前一个结点的指针域,因为任何结点都有前驱结点。若链表没有头结点,则首元素结点没有前驱结点,在其前面插入结点或删除该结点时操作会复杂些,需要进行特殊的处理。
-
对于带头结点的链表,链表的头指针是指向头结点的非空指针,因此,对空链表与非空链表的处理是一样的。
2.2 不带头结点的单链表
单链表的开始节点之前没有附设一个类型相同的空节点。直接从开始节点开始，随着在单链表的开始节点直接插入新的节点，头结点会随时变化(此处的头结点是指谁是第一个节点即为头结点)
3. 双链表
对于一个节点，有些和单链表一样有存储数据的data,指向后方的next（指针）。它拥有单链表的所有操作和内容。但是他还有一个前驱节点pre(指针)
对于双向量表，给定任意一个节点，都可以遍历整个链表的数据。相比于单链表，进行数据查找快，但是空间开销是单链表的两倍，相当于是空间换时间。需要根据具体的实际情况进行选择
4. go语言与链表
4.1 创建单链表
package main
import "fmt"
//链表定义
type LNode struct {
Data interface{}
Next *LNode
}
func main() {
head := &LNode{} // 定义头结点
cur := head // 移动变量
for i := 1; i < 10; i++ { // 创建长度为10的链表
cur.Next = &LNode{} // 指向链表的后驱节点
cur.Next.Data = i // 指向后驱节点的数据域
cur = cur.Next // 指针向后移动一位
}
printNodeList(head)
}
func printNodeList(head *LNode) {
for cur := head.Next; cur != nil; cur = cur.Next {
fmt.Printf("%v ", cur.Data)
}
}
4.2 创建双向链表
package main
import (
"fmt"
"strconv"
"sync"
)
type Data struct {
Name string `json:"name"`
Age int `json:"age"`
}
type Node struct {
Pre *Node
Next *Node
Data Data
}
type NodeList struct {
mutex *sync.Mutex
Head *Node
Tail *Node
Size uint
}
type NodeInterface interface {
Init()
Append(node *Node)
InsertAfterNode(node *Node, data Data) error
InsertIndex(index uint, data Data) error
DelNode(node *Node)
PrintNodeList()
IsEmpty() bool
GetNodeListLen() uint
Exist(node *Node) bool
InsertHead(data Data)
}
func Factory() NodeInterface {
return &NodeList{}
}
// Init,链表的初始化
func (this *NodeList) Init() {
this.Head = nil
this.Tail = nil
this.Size = 0
this.mutex = new(sync.Mutex)
}
// Append,在链表尾部插入节点
func (this *NodeList) Append(node *Node) {
this.mutex.Lock()
defer this.mutex.Unlock()
if this.Size == 0 {
this.Head = node
this.Tail = node
this.Size = 1
return
}
nodePre := this.Tail
this.Tail.Next = node
node.Pre = nodePre
this.Tail = node
this.Size++
}
// Exit, 判断节点是否在当前链表中存在
func (this *NodeList) Exist(node *Node) bool {
var p = this.Head
for p != nil {
if p == node {
return true
}
p = p.Next
}
return false
}
// InsertAfterNode,在指定节点后插入数据
func (this *NodeList) InsertAfterNode(node *Node, data Data) error {
// 如果当前节点存在插入数据，不存在报错
if !this.Exist(node) {
return fmt.Errorf("the current node is not exist")
}
newNode := &Node{
Data: data,
Next: nil,
}
if node.Next == nil {
this.Append(newNode)
} else if node.Pre == nil {
newNode.Next = node.Next
newNode.Pre = node
node.Next = newNode
this.Size++
} else {
newNode.Next = node.Next
newNode.Pre = node
node.Next = newNode
this.Size++
}
return nil
}
// InsertIndex,在指定下标处插入数据
func (this *NodeList) InsertIndex(index uint, data Data) error {
// 判断下标值是否合法
if index > this.Size {
return fmt.Errorf("the index is more than the nodeList subscript")
}
// index=0,即在链表头部插入数据
if index == 0 {
this.InsertHead(data)
return nil
}
// 遍历到指定下标对应的节点
var p = this.Head
for i := 0; i < int(index); i++ {
p = p.Next
}
if err := this.InsertAfterNode(p, data); err != nil {
return err
}
return nil
}
// InsertHead,在链表头部插入数据
func (this *NodeList) InsertHead(data Data) {
newNode := &Node{
Data: data,
Next: this.Head,
}
this.Head.Pre = newNode
this.Head = newNode
if this.Size == 0 {
this.Tail = newNode
}
this.Size++
}
// DelNode,删除指定节点
func (this *NodeList) DelNode(node *Node) {
// 判断是否是头节点
if this.Head == node {
this.Head = this.Head.Next
}
// 判断是否是尾节点
if this.Tail == node {
p := this.Head
for p.Next != node {
p = p.Next
}
p.Next = nil
p.Next.Pre = nil
}
// 如果是中间节点
p := this.Head
for p.Next != node {
p = p.Next
}
p.Next = node.Next
node.Next.Pre = node.Pre
this.Size--
}
// GetNodeListLen,获取链表长度
func (this *NodeList) GetNodeListLen() uint {
return this.Size
}
// IsEmpty,判断链表是否为空
func (this *NodeList) IsEmpty() bool {
return this.Size == 0
}
// PrintNodeList, 打印链表信息
func (this *NodeList) PrintNodeList() {
fmt.Println("==============打印链表信息==============")
if this.IsEmpty() {
fmt.Println("当前链表为空")
}
fmt.Printf("链表长度 : %v\n", this.GetNodeListLen())
p := this.Head
//for p.Next != nil {
for {
fmt.Printf("the node : %v\n", p.Data)
if p.Next == nil {
break
} else {
p = p.Next
}
}
fmt.Println("==============打印链表信息==============")
}
func main() {
factory := Factory()
factory.Init()
for i := 0; i <= 10; i++ {
factory.Append(&Node{
Data: Data{
Name: "test_" + strconv.Itoa(i),
Age: i,
},
Next: nil,
})
}
fmt.Println("=============初始化的链表=============")
factory.PrintNodeList()
fmt.Println("=============初始化的链表=============")
fmt.Println("")
fmt.Println("")
fmt.Println("")
fmt.Println("=============在指定节点后插入数据=============")
data := Data{
Name: "zhangyang",
Age: 28,
}
node := factory.(*NodeList).Head
for i := 0; i < 6; i++ {
node = node.Next
}
if err := factory.InsertAfterNode(node, data); err != nil {
panic(err)
}
if err := factory.InsertAfterNode(node.Next, data); err != nil {
panic(err)
}
factory.PrintNodeList()
fmt.Println("=============在指定节点后插入数据=============")
fmt.Println("")
fmt.Println("")
fmt.Println("")
fmt.Println("=============在指定下标插入数据=============")
data = Data{
Name: "taoyingying",
Age: 25,
}
if err := factory.InsertIndex(8, data); err != nil {
panic(err)
}
factory.PrintNodeList()
fmt.Println("=============在指定下标插入数据=============")
fmt.Println("")
fmt.Println("")
fmt.Println("")
fmt.Println("=============删除指定节点=============")
node = factory.(*NodeList).Head
for i := 0; i < 7; i++ {
node = node.Next
}
factory.DelNode(node)
factory.PrintNodeList()
fmt.Println("=============删除指定节点=============")
}
