Golang实现常见数据结构-(1)链表(数据结构和算法)

一、链表

定义：

链表由一个个数据节点组成的，它是一个递归结构，要么它是空的，要么它存在一个指向另外一个数据节点的引用。

链表，可以说是最基础的数据结构

实现思路：每个结构体都保存下一个元素的指针(比如：初始化第二个元素的时候，就把指针赋值给第一结构体的元素)

最简单的链表如下：

package main

import "fmt"

//定义一个结构体
type LinkNode struct {
   Data int64 //节点数据
   NextNode *LinkNode //下一个节点的地址
}

func main()  {
　　//第一个节点
   node := new(LinkNode)
   node.Data = 4
　　//第二个节点
   node1 := new(LinkNode)
   node1.Data = 5
　　//第一个节点保存第二个节点地址
   node.NextNode = node1
　　//第三个节点
   node2 := new(LinkNode)
   node2.Data = 6
　　//第二个节点保存第三个节点地址
　　node1.NextNode = node2

　　//打印链表
   now := node
   for now != nil{
      fmt.Println(now.Data)
　　　　//最后一个节点的NextNode为nil 跳出循环
      now = now.NextNode
      //fmt.Println(now)
   }
}

打印出：　　 　　
　　4
　　5　　
　　6
进一步优化如下：
　　

package main

import "fmt"

type ListNode struct {
   Data int64 //数据
   NextNode *ListNode //下一个节点
}

//头节点
type ListHead struct {
   HeadNode *ListNode
}

//从头节点开始，一次往下添加
func (ListHead *ListHead) Add(value int64)  {
   newNode := &ListNode{Data: value}

   node := ListHead.HeadNode
   //头节点为空 赋值
   if node == nil{
      ListHead.HeadNode = newNode
   }else {
      //最后一个的next为nil
      for node.NextNode != nil {
         node = node.NextNode
      }
      //相当于ListHead.HeadNode.NextNode = newNode
      node.NextNode = newNode
   }

}

//打印链表
func (ListHead *ListHead) ListPrint()  {
   newNode  := ListHead.HeadNode
   for newNode != nil {
      fmt.Println(newNode.Data)
      newNode = newNode.NextNode
   }
}



func main()  {
   node := &ListHead{}
   node.Add(4)
   node.Add(5)
   node.Add(6)

   node.ListPrint()


}