湖北手机网站建设/有什么推广软件

https://github.com/Rain-Life/learnGo

//定义结点中数据的类型为接口类型，可收任意类型数据
type Object interface {}//定义结点的结构体
type Node struct {Data ObjectNext *Node
}//定义链表的结构体
type List struct {headNode *Node
}

func (list *List) IsEmpty() bool  {if list.headNode == nil {return true}return false
}

func (list *List) Length() int {currentNode := list.headNodecount := 0for currentNode != nil {count++currentNode = currentNode.Next}return count
}

func (list *List) AddFromHead(data Object) *Node {node := &Node{Data:data}if list.IsEmpty() {list.headNode = nodereturn node}node.Next = list.headNodelist.headNode = nodereturn node
}

func (list *List) Append(data Object) {node := &Node{Data: data}if list.IsEmpty() {list.headNode = node} else {currentNode := list.headNodefor currentNode.Next != nil {currentNode = currentNode.Next}currentNode.Next = node}
}

func (list *List) Insert(position int, data Object) {if position <= 1 {list.AddFromHead(data)} else if position > list.Length() {list.Append(data)} else {pre := list.headNodecount := 1for count < (position-1) {pre = pre.Nextcount++}//循环退出以后pre刚好在position-1的位置node := &Node{Data: data}node.Next = pre.Nextpre.Next = node}
}

func (list *List) RemoveHeadNde() Object {if list.IsEmpty() {fmt.Println("链表为空")return nil}currentNode := list.headNodeif list.headNode.Next == nil {list.headNode = nilreturn currentNode.Data}list.headNode = currentNode.Nextreturn currentNode.Data
}

func (list *List) RemoveLastNode() Object {if list.IsEmpty() {return "链表为空"}currentNode := list.headNodefor currentNode.Next.Next != nil {currentNode = currentNode.Next}data := currentNode.Next.DatacurrentNode.Next = nilreturn data
}

func (list *List) Remove(data Object)  {pre := list.headNodeif pre.Data == data{list.headNode = pre.Next} else {for pre.Next != nil {if pre.Next.Data == data {pre.Next = pre.Next.Next} else {pre = pre.Next}}}
}

func (list *List) RemovePosition(position int)  {pre := list.headNodeif position <= 1 {list.headNode = nil} else if position > list.Length() {fmt.Println("超出链表长度")} else {count :=1for count != position-1 && pre.Next != nil {count++pre = pre.Next}pre.Next = pre.Next.Next}
}

func (list *List) Contain(data Object) bool {currentNode := list.headNodefor currentNode != nil {if currentNode.Data == data {return true}currentNode = currentNode.Next}return false
}

func (list *List) Traverse()  {if list.IsEmpty() {fmt.Println("链表为空")}currentNode := list.headNodefor currentNode != nil {fmt.Printf("%vt", currentNode.Data)currentNode = currentNode.Next}
}

package mainimport ("fmt""learnGo/linkedList/node"
)func print(list node.List)  {fmt.Printf("链表长度%dn", list.Length())fmt.Println("遍历链表所有结点：")list.Traverse()fmt.Println()fmt.Println()
}func main() {list := node.List{}//向链表的尾部追加元素fmt.Println("++++++++1、向链表尾部追加结点++++++++")list.Append(3)list.Append(8)list.Append(1)list.Append(9)list.Append("PHP")list.Append("Golang")list.Append("Java")list.Append("JavaScript")print(list)fmt.Println("++++++++2、判断链表是否为空++++++++")fmt.Printf("链表是否为空：%v", list.IsEmpty())fmt.Println()fmt.Println()//向链表的头部添加元素fmt.Println("++++++++3、向链表的头部添加一个结点++++++++")fmt.Println()list.AddFromHead("firstNode")print(list)fmt.Println("++++++++4、向链表尾部添加结点++++++++")fmt.Println()list.Append("lastNode")print(list)fmt.Println("++++++++5、向链表尾部添加结点++++++++")fmt.Println()list.Insert(3, "thirdNode")print(list)fmt.Println("++++++++6、删除链表头结点++++++++")fmt.Println()list.RemoveHeadNde()print(list)fmt.Println("++++++++7、删除链表尾结点++++++++")fmt.Println()list.RemoveLastNode()print(list)fmt.Println("++++++++8、删除链表中指定值的结点++++++++")fmt.Println()list.Remove(9)print(list)fmt.Println("++++++++9、删除链表中指定位置的结点++++++++")fmt.Println()list.RemovePosition(3)print(list)fmt.Println("++++++++10、查询链表中是否包含某一个结点++++++++")fmt.Println()res := list.Contain("Golang")fmt.Printf("是否存在Golang结点：%vn", res)print(list)
}

package loopLinkListimport "fmt"//循环链表
type Object interface {}type Node struct {Data ObjectNext *Node
}type List struct {headNode *Node
}//判断循环链表是否为空（与单链表的实现没有区别）
func (list *List) IsEmpty() bool {if list.headNode == nil {return true}return false
}//获取循环链表的长度（与单链表的获取长度区别在于循环的终止条件）
func (list *List) Length() int {if list.headNode == nil {return 0}currentNode := list.headNodecount := 1for currentNode.Next != list.headNode {count++currentNode = currentNode.Next}return count
}//向循环链头部添加结点
func (list *List) AddFromHead(data Object) {node := &Node{Data: data}//链表为空的情况if list.IsEmpty() {list.headNode = nodelist.headNode.Next = list.headNode //单链表没有这一步} else {currentNode := list.headNodefor currentNode.Next != list.headNode { //需要先找到最后一个结点currentNode = currentNode.Next}node.Next = list.headNodecurrentNode.Next = node //单链表没有这一步操作，将最后一个节点的next指向头结点list.headNode = node}
}//向循环链表的尾部添加结点
func (list *List) Append(data Object) {node := &Node{Data: data}if list.IsEmpty() {list.headNode = nodelist.headNode.Next = node} else {currentNode := list.headNodefor currentNode.Next != list.headNode {currentNode = currentNode.Next}currentNode.Next = nodenode.Next = list.headNode //单链表没有这一步操作（让最后一个节点指向头结点）}
}//向循环链表的指定位置添加结点（跟单链表是一样的）
func (list *List) Insert(position int, data Object) {if position <= 1 {list.AddFromHead(data)} else if position > list.Length() {list.Append(data)} else {currentNode := list.headNodecount := 1for count < position-1 {currentNode = currentNode.Nextcount++}node := &Node{Data: data}node.Next = currentNode.NextcurrentNode.Next = node}
}//删除循环链表的头结点
func (list *List) RemoveHeadNde() {if list.IsEmpty() {fmt.Println("链表是空的")return}currentNode := list.headNodelastNode := list.headNode//考虑循环链表只有一个结点的情况if currentNode.Next == list.headNode {list.headNode = nilreturn}for lastNode.Next != list.headNode {lastNode = lastNode.Next}list.headNode = currentNode.NextlastNode.Next = list.headNode
}//删除循环链表的尾结点
func (list *List) RemoveLastNode() {if list.IsEmpty() {fmt.Println("链表是空的")return}currentNode := list.headNode//考虑循环链表只有一个结点的情况if currentNode.Next == list.headNode {list.headNode = nilreturn}for currentNode.Next.Next != list.headNode {currentNode = currentNode.Next}currentNode.Next = list.headNode
}//删除循环链表中指定位置的节点 (需考虑删除的结点是不是第一个或最后一个)
func (list *List) RemovePosition(position int) {if list.IsEmpty() {fmt.Println("链表为空")return}if position <= 1 {list.RemoveHeadNde()} else if position > list.Length() {list.RemoveLastNode()} else {currentNode := list.headNodecount := 1if count != position-1 && currentNode.Next != list.headNode{count++currentNode = currentNode.Next}currentNode.Next = currentNode.Next.Next}
}//删除循环链表中指定值的结点
func (list *List) Remove(data Object) {if list.IsEmpty() {fmt.Println("链表为空")return}currentNode := list.headNode//删除的结点为头结点时if currentNode.Data == data {list.RemoveHeadNde()return}for currentNode.Next != list.headNode {if currentNode.Next.Data == data {currentNode.Next = currentNode.Next.Nextreturn} else {currentNode = currentNode.Next}}if currentNode.Next == list.headNode {list.RemoveLastNode()}
}//查找循环链表中指定结点
func (list *List) Contain(data Object) bool {if list.IsEmpty() {return false}currentNode := list.headNodefor currentNode.Next != list.headNode {if currentNode.Data == data {return true}currentNode = currentNode.Next}if currentNode.Data == data {return true}return false
}//遍历循环链表
func (list *List) Traverse() {if list.IsEmpty() {fmt.Println("循环链表为空")return}currentNode := list.headNodeif currentNode.Next == list.headNode { //兼容循环链表只有一个结点的情况fmt.Printf("%vt", currentNode.Data)return}for currentNode.Next != list.headNode {fmt.Printf("%vt", currentNode.Data)currentNode = currentNode.Next}fmt.Printf("%vt", currentNode.Data)
}

package mainimport ("fmt""learnGo/linkedList/loopLinkList"
)func print(list loopLinkList.List)  {fmt.Printf("链表长度：%dn", list.Length())fmt.Println("遍历链表所有结点：")list.Traverse()fmt.Println()fmt.Println()
}func main() {list := loopLinkList.List{}fmt.Println("++++++++1、判断链表是否为空++++++++")fmt.Printf("链表是否为空：%vn", list.IsEmpty())print(list)fmt.Println("++++++++2、获取链表长度++++++++")fmt.Printf("获取链表长度：%dn", list.Length())print(list)fmt.Println("++++++++3、向循环链头部添加结点++++++++")list.AddFromHead("firstNode")print(list)fmt.Println("++++++++4、向循环链尾部添加结点++++++++")list.Append("lastNode")print(list)fmt.Println("++++++++5、向循环链指定位置添加结点++++++++")list.Insert(1,"secondNode")print(list)fmt.Println("++++++++6、删除循环链的头结点++++++++")list.RemoveHeadNde()print(list)fmt.Println("++++++++7、删除循环链的尾结点++++++++")list.RemoveLastNode()print(list)fmt.Println("++++++++8、查找循环链表中指定结点++++++++")fmt.Printf("是否包含secondNode节点：%vn", list.Contain("secondNode"))print(list)fmt.Println("++++++++9、删除循环链表中指定位置的结点++++++++")list.RemovePosition(1)print(list)fmt.Println("++++++++10、删除循环链表中指定值的结点++++++++")list.Remove("lastNode")print(list)}

package doublyLinkedListimport ("fmt"
)//双向链表
type Object interface {}type Node struct {Data ObjectPrev,Next *Node
}type List struct {headNode *Node
}//说明
/**
1、如果结点的Next指向为null，则说明是最后一个结点
2、第一个结点的prev指向为空
3、双向链表和单向链表差不多，区别就是删除和添加结点的时候更方便了，因为很方便的可以获取到前一个结点
*///判断双向链表是否为空
func (list *List) IsEmpty() bool {if list.headNode == nil {return true}return false
}//遍历双向链表（跟遍历单链表一模一样）
func (list *List) Traverse() {if list.IsEmpty() {fmt.Println("双线链表为空")return}currentNode := list.headNodefor currentNode != nil {fmt.Printf("%vt", currentNode.Data)currentNode = currentNode.Next}
}//获取双向链表的长度（跟获取单链表长度一模一样）
func (list *List) Length() int {if list.IsEmpty() {return 0}count := 0currentNode := list.headNodefor currentNode != nil {count++currentNode = currentNode.Next}return count
}//从双向链表头部开始增加结点
func (list *List) AddFromHead(data Object) *Node {node := &Node{Data: data}if list.IsEmpty() {list.headNode = nodereturn node}list.headNode.Prev = nodenode.Next = list.headNodelist.headNode = nodereturn node
}//从双向链表尾部添加结点
func (list *List) Append(data Object) {node := &Node{Data: data}if list.IsEmpty() {list.headNode = node} else {currentNode := list.headNodefor currentNode.Next != nil {currentNode = currentNode.Next}currentNode.Next = nodenode.Prev = currentNode}
}/*** 向双向链表的指定位置插入结点** 说明：在单向链表中，我是通过找到我要插入的这个结点的前一个结点，然后将要插入的结点，* 插入到这个结点的后边（因为插入结点需要找到当前结点的前一个结点，为了避免再次遍历找前一个结点，所以采用了这种方式）* 而双向链表就不需要这么做了，找到指定位置的结点，新的插入到它前边就可以了*/
func (list *List) Insert(position int, data Object) {if position <= 1 {list.AddFromHead(data)} else if position > list.Length() {list.Append(data)} else {currentNode := list.headNodecount := 1for count != position {currentNode = currentNode.Nextcount++}//找到了指定位置的结点，然后将要插入的结点，插到这个节点前边即可(注意顺序，画图最容易理解)node := &Node{Data: data}node.Next = currentNodenode.Prev = currentNode.PrevcurrentNode.Prev.Next = nodecurrentNode.Prev = node}
}//删除链表头结点
func (list *List) RemoveHeadNde() Object {if list.IsEmpty() {fmt.Println("链表为空")return nil}currentNode := list.headNodeif currentNode.Next == nil && currentNode.Prev == nil {list.headNode = nilreturn currentNode.Data}list.headNode = currentNode.NextcurrentNode.Prev = nilreturn currentNode.Data
}//删除链表尾结点
func (list *List) RemoveLastNode() Object {if list.IsEmpty() {fmt.Println("链表为空")return nil}if list.headNode.Next == nil {list.headNode = nil}currentNode := list.headNodefor currentNode.Next != nil {currentNode = currentNode.Next}currentNode.Prev.Next = nilreturn currentNode.Prev.Data
}//删除双向表中指定值的结点
func (list *List) Remove(data Object)  {if list.IsEmpty() {fmt.Println("链表为空")return}currentNode := list.headNodeif list.headNode.Next == nil && list.headNode.Data == data {list.headNode = nil}fmt.Println(data, currentNode.Data, currentNode.Data == data)for currentNode != nil {if currentNode.Data == data && currentNode == list.headNode {list.headNode = currentNode.Next} else if currentNode.Data == data && currentNode.Prev != nil {currentNode.Prev.Next = currentNode.NextcurrentNode.Next.Prev = currentNode.Prev} else {currentNode = currentNode.Next}}
}//删除双向链表中指定位置的结点
func (list *List) RemovePosition(position int) {if list.IsEmpty() {fmt.Println("链表为空")return}if position <=1 {list.RemoveHeadNde()} else if position > list.Length() {list.RemoveLastNode()} else {currentNode := list.headNodecount := 1for count != position {count++currentNode = currentNode.Next}currentNode.Prev.Next = currentNode.NextcurrentNode.Next.Prev = currentNode.Prev}
}//查询双向链表中是否包含某一个结点(和单向链表一样)
func (list *List) Contain(data Object) bool {if list.IsEmpty() {fmt.Println("链表为空")return false}currentNode := list.headNodefor currentNode != nil {if currentNode.Data == data {return true}currentNode = currentNode.Next}return false
}

package mainimport ("fmt""learnGo/linkedList/doublyLinkedList"
)func print(list doublyLinkedList.List)  {fmt.Printf("链表长度%dn", list.Length())fmt.Println("遍历链表所有结点：")list.Traverse()fmt.Println()fmt.Println()
}func main() {list := doublyLinkedList.List{}fmt.Println("++++++++1、判断链表是否为空++++++++")fmt.Printf("链表是否为空：%v", list.IsEmpty())fmt.Println()fmt.Println()fmt.Println("++++++++2、向双向链表头部添加元素++++++++")fmt.Println()list.AddFromHead(1)list.AddFromHead(2)list.AddFromHead(3)print(list)fmt.Println("++++++++3、向双向链表尾部添加元素++++++++")fmt.Println()list.Append("Golang")list.Append("PHP")list.Append("Java")print(list)fmt.Println("++++++++4、向双向链表的指定位置插入结点++++++++")fmt.Println("++++++++(1)向双向链表的【第一个】位置插入结点++++++++")list.Insert(1, "First")print(list)fmt.Println("++++++++(2)向双向链表的【第三个】位置插入结点++++++++")list.Insert(3, "Third")print(list)fmt.Println("++++++++(3)向双向链表的【最后】位置插入结点++++++++")list.Insert(list.Length()+1, "Last")print(list)fmt.Println("++++++++5、删除双向链表的头结点++++++++")fmt.Println()list.RemoveHeadNde()print(list)fmt.Println("++++++++6、删除双向链表的尾结点++++++++")fmt.Println()list.RemoveLastNode()print(list)fmt.Println("++++++++7、删除双向表中指定值的结点++++++++")list.Remove(3)//这里的类型要和你插入时的类型一致（弱类型语言写习惯了，很容易忘了）print(list)fmt.Println("++++++++8、删除双向表中指定位置的结点++++++++")fmt.Println("++++++++(1)删除双向链表的【第一个】位置结点++++++++")list.RemovePosition(1)print(list)fmt.Println("++++++++(2)删除双向链表的【第三个】位置结点++++++++")list.RemovePosition(3)print(list)fmt.Println("++++++++(3)删除双向链表的【最后】位置结点++++++++")list.RemovePosition(list.Length())print(list)fmt.Println("++++++++9、查询双向链表中是否包含某一个结点++++++++")fmt.Println()fmt.Printf("是否存在Golang结点：%vn", list.Contain(2))
}

package doublyLoopLinkedListimport ("fmt"
)type Object interface {}type Node struct {Data ObjectPrev,Next *Node
}type List struct {headNode *Node
}//判断双向循环链表是否为空
func (list *List) IsEmpty() bool {if list.headNode == nil {return true}return false
}//遍历双向循环链表
func (list *List) Traverse() {if list.IsEmpty() {fmt.Println("链表为空")return}if list.headNode.Next == nil {//兼容双向循环链表只有一个结点的情况fmt.Printf("%vt", list.headNode.Data)return}currentNode := list.headNodefor currentNode.Next != list.headNode {fmt.Printf("%vt", currentNode.Data)currentNode = currentNode.Next}fmt.Printf("%vt", currentNode.Data)
}//获取双向循环链表的长度
func (list *List) Length() int {if list.IsEmpty() {return 0}count := 1currentNode := list.headNodefor currentNode.Next != list.headNode {count++currentNode = currentNode.Next}return count
}//从双向循环链表头部添加结点(一定一定要画图，比较好理解)
func (list *List) AddFromHead(data Object) *Node {node := &Node{Data: data}if list.IsEmpty() {list.headNode = nodereturn node}currentNode := list.headNodeif currentNode.Next == nil { //考虑只有一个节点的时候node.Prev = currentNodecurrentNode.Next = nodenode.Next = currentNodecurrentNode.Prev = nodelist.headNode = nodereturn node}node.Prev = currentNode.PrevcurrentNode.Prev.Next = nodecurrentNode.Prev = nodenode.Next = currentNodelist.headNode = nodereturn node
}//从双向循环链表尾部添加结点
func (list *List) Append(data Object) *Node {node := &Node{Data: data}if list.IsEmpty() {list.headNode = nodereturn node}currentNode := list.headNodecurrentNode.Prev.Next = nodenode.Prev = currentNode.PrevcurrentNode.Prev = nodenode.Next = currentNodereturn node
}//向双向循环链表的指定位置插入结点
func (list *List) Insert(position int, data Object) {if position <=1 {list.AddFromHead(data)} else if position > list.Length() {list.Append(data)} else {node := &Node{Data: data}currentNode := list.headNodecount := 1for count != position {count++currentNode = currentNode.Next}//将待插入的节点插入到当前节点的前边即可(这块的逻辑其实和双向链表的在中间位子插入结点逻辑一样)currentNode.Prev.Next = nodenode.Prev = currentNode.PrevcurrentNode.Prev = nodenode.Next = currentNode}
}//删除双向循环链表头结点
func (list *List) RemoveHeadNde() Object {if list.IsEmpty() {fmt.Println("双向循环链表为空")return ""}currentNode := list.headNodeif currentNode.Next == nil {//只有一个结点的情况list.headNode = nilreturn currentNode.Data}currentNode.Prev.Next = currentNode.NextcurrentNode.Next.Prev = currentNode.Prevlist.headNode = currentNode.Nextreturn currentNode.Data
}//删除双向循环链表尾结点
func (list *List) RemoveLastNode() Object {if list.IsEmpty() {fmt.Println("双向循环链表为空")return ""}currentNode := list.headNodeif currentNode.Next == nil {//只有一个结点的情况list.headNode = nilreturn list.headNode.Data}lastNode := list.headNode.PrevlastNode.Prev.Next = currentNodecurrentNode.Prev = lastNode.Prevreturn lastNode.Data
}//删除双向循环链表中指定值的结点
func (list *List) Remove(data Object) bool {if list.IsEmpty() {fmt.Println("双向循环链表为空")return false}//如果链表只有一个节点if list.headNode.Next == nil {if list.headNode.Data == data {list.headNode = nilreturn true}return false}currentNode := list.headNode//如果值刚好等于第一个节点的值if currentNode.Data == data {list.RemoveHeadNde()return true}//如果值刚好等于最后一个结点的值for currentNode.Next != list.headNode {if currentNode.Data == data {//删除中间节点currentNode.Prev.Next = currentNode.NextcurrentNode.Next.Prev = currentNode.Prevreturn true} else {currentNode = currentNode.Next}}if currentNode.Data == data { //刚好是最后一个结点的时候list.RemoveLastNode()return true}return false
}//删除双向循环链表中指定位置的结点
func (list *List) RemovePosition(position int) {if list.IsEmpty() {fmt.Println("双向循环链表为空")return}if position <= 1 {list.RemoveHeadNde()} else if position > list.Length() {list.RemoveLastNode()} else {currentNode := list.headNodecount := 1for count != position {count++currentNode = currentNode.Next}currentNode.Prev.Next = currentNode.NextcurrentNode.Next.Prev = currentNode.Prev}
}//查询双向循环链表中是否包含某一个结点(跟循环链表的查找逻辑一样)
func (list *List) Contain(data Object) bool {if list.IsEmpty() {fmt.Println("双向循环链表为空")return false}currentNode := list.headNodefor currentNode.Next != list.headNode {if currentNode.Data == data {return true}currentNode = currentNode.Next}if currentNode.Data == data {return true}return false
}

package mainimport ("fmt""learnGo/linkedList/doublyLoopLinkedList"
)func print(list doublyLoopLinkedList.List)  {fmt.Printf("链表长度%dn", list.Length())fmt.Println("遍历链表所有结点：")list.Traverse()fmt.Println()fmt.Println()
}func main() {list := doublyLoopLinkedList.List{}fmt.Println("++++++++1、判断链表是否为空++++++++")fmt.Printf("链表是否为空：%v", list.IsEmpty())fmt.Println()fmt.Println()fmt.Println("++++++++2、向双向循环链表头部添加结点++++++++")fmt.Println()list.AddFromHead(1)list.AddFromHead(2)list.AddFromHead(3)print(list)fmt.Println("++++++++3、向双向循环链表尾部添加结点++++++++")fmt.Println()list.Append("lastNode")print(list)fmt.Println("++++++++4、向双向循环链表指定位置添加结点++++++++")fmt.Println()list.Insert(1,"firstNode")print(list)fmt.Println("++++++++5、删除双向循环链表头结点++++++++")fmt.Println()list.RemoveHeadNde()print(list)fmt.Println("++++++++6、删除双向循环链表尾结点++++++++")fmt.Println()list.RemoveLastNode()print(list)fmt.Println("++++++++7、删除双向循环链表中指定值的结点++++++++")fmt.Println()list.Remove(1)print(list)fmt.Println("++++++++8、删除双向循环链表中指定位置的结点++++++++")fmt.Println()list.RemovePosition(list.Length()-1)print(list)fmt.Println("++++++++9、查询双向循环链表中是否包含某一个结点++++++++")fmt.Println()fmt.Println("是否包含值为firstNode的结点：", list.Contain("firstNode"))print(list)
}