golang Dockerfile自动生成 golang container

不是容器哈（容器——>百度搜菜鸟教程），里面有三个部分：heap(堆),list(双向链表),ring(环)。

         本文是对其中的list.go的学习，既然是学习源码：那就直接贴代码吧，里面注释变成了中文，仅供参考。

package list

//链表的元素结点
type Element struct {
	//前项和后项 结点
	next, prev   *Element
	//list :这个节点所在的链表
	list   *List
	// value 这个节点存储的值
	Value  interface{}
}

//方法名：Next()
//参数：无
//返回：结点的下一个元素或者nil
//定位：接口
func (e *Element) Next() *Element{
	// e所属的list不为空并且e.next不是其所属list的根结点
	if p := e.next; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

// 方法名：Prev()
//参数：无
//返回：结点的前一个元素或者nil
//定位：接口
func (e *Element) Prev() *Element{
	//e 所属的list不为空且e.prev不是其所属list的根结点
	if p := e.prev; e.list != nil && p != &e.list.root {
		return p
	}
	return nil
}

//双向链表
type List struct {
	root   Element      //链表的根结点
	len    int          //链表的长度
}

//初始化list
//链表含有根结点，空链表只含有根结点
func (l *List)Init() *List{
	l.root.next = &l.root
	l.root.prev = &l.root
	l.len = 0
	return l
}

//新建一个链表(实际是new一个List对象，然后调用其Init())
func New() *List {return new(List).Init()}

/*
函数名：Len()
功能：返回l的长度
参数：无
定位：接口
 */
 func(l *List) Len() int{
 	return l.len
 }

/*
函数名：Front()
功能：返回链表的第一个元素(空链表返回空)
参数：无
定位：接口
 */
func(l *List) Front() *Element{
	if l.len == 0{
		return nil
	}
	return l.root.next
}

/*
函数名：Back()
功能：返回链表的最后一个元素(空链表返回空)
参数：无
定位：接口
 */
func(l *List)Back() *Element{
	if l.len == 0{
		return nil
	}
	return l.root.prev
}

/*
函数名：lazyInit()
功能：防止空链表不是环状结构
参数：无
定位：内部函数
 */
 func (l *List)lazyInit() {
	if l.root.next == nil {
		l.Init()
	}
 }

 /*
 函数名：insert()
 功能：往指定元素之后插入元素
 参数: 待插入元素e 和位置元素
 返回：一个结点
 定位：内部函数
  */
func(l *List)insert(e ,at *Element)  *Element{
	n := at.next
	at.next = e
	e.prev = at
	e.next = n
	n.prev = e
	e.list = l
	l.len++
	return e
}

/*
方法名：insertValue(v interface{},at *Element) *Element
功能：往链表结点后插入某个值，也就是插入一个值为v的结点
返回：一个结点
定位：内部函数
 */
func (l *List)insertValue(v interface{}, at *Element) *Element{
	return l.insert(&Element{Value: v}, at)
}

/*
函数名：remove()
功能：从链表l中移除一个结点e
参数：e *Element
返回：被移除的结点
定位：内部函数
 */
func (l *List)remove(e *Element) *Element{
	e.prev.next = e.next
	e.next.prev = e.prev
	e.prev = nil
	e.next = nil
	e.list = nil
	l.len--
	return e
}

/*
方法名：Remove()
功能：将结点e从链表l中移除
参数：结点e
返回：结点的Value
定位：接口
 */
func (l *List)Remove(e *Element) interface{}{
	if e.list == l {
		l.remove(e)
	}
	return e.Value
}

/*
方法名：PushFront()
功能：往链表l的头部插入一个值为v的结点(PS:根节点的后面的第一个结点位置)
参数：v interface{}
返回：插入的结点
定位：接口
 */
func (l *List)PushFront(v interface{}) *Element{
	l.lazyInit()                                     //避免空链表不是环
	return l.insertValue(v,&l.root)
}

/*
方法名：PushBack()
功能：往链表l的尾部插入一个值v的结点
参数：v interface{}
返回：插入的结点
定位：接口
 */
func (l *List) PushBack(v interface{}) *Element {
	l.lazyInit()                             //避免空链表不是环
	return l.insertValue(v,l.root.prev)
}

/*
方法名：InsertBefore()
功能：往链表上的某个标记结点之后插入某个结点
参数：v interface{}   mark *Element
返回：被插入的结点
定位：接口
 */
func (l *List)InsertBefore(v interface{}, mark *Element) *Element {
	//如果标记mark 不在链表l上，返回空
	if mark.list != l {
		return nil
	}
	return l.insertValue(v,mark.prev)
}

/*
方法名：InsertAfter()
功能：往链表的某个结点之前插入一个值为v 的结点
参数：v interface{} mark *Element
返回：被插入的结点
定位：接口
 */
func (l *List)InsertAfter(v interface{}, mark *Element) *Element{
	//如果标记结点mark不在链表l上，则返回nil
	if mark.list != l{
		return nil
	}
	return l.insertValue(v,mark)
}

/*
方法名：MoveToFront()
功能：将结点e移到链表l的头部
参数：e  *Element
返回：无
定位：接口
 */
func (l *List)MoveToFront(e *Element){
	//如果e不属于这个链表或者e已经在这个链表的头部，则退出
	if e.list != l || l.root.next == e {
		return
	}
	l.insert(l.remove(e), &l.root)
}

/*
方法名：MoveToBack()
功能：将结点e移到链表l的尾部
参数：e *Element
返回：无
定位：接口
 */
func (l *List)MoveToBack(e *Element){
	//如果结点e 不属于链表l，或者结点e 本来就位于链表的尾部
	if e.list != l || l.root.prev == e {
		return
	}
	l.insert(l.remove(e),l.root.prev)
}

/*
方法名：MoveBefor()
功能：将结点e移到某个结点mark 的前面(PS: 结点e 和 mark都是链表l内的结点)
参数：e,mark *Element
返回：无
定位：接口
 */
func (l *List)MoveBefor(e, mark *Element) {
	if e.list != l || mark.list != l || e == mark {
		return
	}
	l.insert(l.remove(e),mark.prev)
}

/*
方法名：MoveAfter()
功能：将结点e 移到某个结点mark的后面(PS: 结点e和mark都是链表l内的结点)
参数：e,mark *Element
返回：无
定位：接口
 */
func (l *List) MoveAfter(e,mark *Element)  {
	if e.list != l || mark.list != l || e == mark{
		return
	}
	l.insert(l.remove(e),mark)
}

/*
方法名：PushBackList()
功能：将其他链表复制到链表l的尾部
参数：other *List
返回：无
定位：接口
 */
func (l *List) PushBackList(other *List){
	//确保l是一个闭环List
	l.lazyInit()
	//依次将otherList中的每个元素取出，添加到链表l中
	for i,e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next(){
		l.insertValue(e.Value,l.root.prev)
	}
}

/*
方法名：PushFrontList()
功能：将其他链表复制到链表的头部
参数：other *List
返回：无
定位：接口
 */
 func (l *List) PushFrontList(other *List){
 	//确保l是一个闭环List
 	l.lazyInit()
 	for i,e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev(){
 		l.insertValue(e.Value,l.root.prev)
	}
 }

         下面再插入一个官方给出来的小例子：

func Example_1(){
	//创建一个双向链表
	l := list.New()
	//向链表l中插入一个值是4的结点,位置是链表的头部，并返回这个结点
	e4 := l.PushBack(4)
	//向链表l中插入一个值是1的结点,位置是链表的头部，并返回这个结点
	e1 := l.PushFront(1)
	//在e4结点前插入一个值为3的结点
	l.InsertBefore(3,e4)
	//在结点e1后插入一个值为2的结点
	l.InsertAfter(2,e1)
	//打印链表l内部的元素
	for e := l.Front(); e != nil; e = e.Next(){
		fmt.Println(e.Value)
	}
}