diff --git a/readme.md b/readme.md index cba9bb1..b6c7ce3 100644 --- a/readme.md +++ b/readme.md @@ -64,6 +64,8 @@ 2020/12/7 :更新bit位操作工作 BitTool +2020/12/7 :添加container包使用示例和源码分析 + # mod vendor模式加载包 通过go mod的方式加载的github上面的包会有报红的问题，但是包本身是可以运行的，这样就是会有一个问题，如果你想要点击去看方法的内容，没办法做到 diff --git a/test/jdkContainer/SourceAnalysis/heap.go b/test/jdkContainer/SourceAnalysis/heap.go new file mode 100644 index 0000000..73a4b83 --- /dev/null +++ b/test/jdkContainer/SourceAnalysis/heap.go @@ -0,0 +1,157 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package heap provides heap operations for any type that implements +// heap.Interface. A heap is a tree with the property that each node is the +// minimum-valued node in its subtree. +// +// The minimum element in the tree is the root, at index 0. +// +// A heap is a common way to implement a priority queue. To build a priority +// queue, implement the Heap interface with the (negative) priority as the +// ordering for the Less method, so Push adds items while Pop removes the +// highest-priority item from the queue. The Examples include such an +// implementation; the file example_pq_test.go has the complete source. +// +//read note 拷贝一个代码过来解析.感觉在go里面拷贝代码简单多了，依赖可以直接使用。我在这边使用read note(自定义todo标识)来标识我的解析. +package SourceAnalysis + +import "sort" + +// The Interface type describes the requirements +// for a type using the routines in this package. +// Any type that implements it may be used as a +// min-heap with the following invariants (established after +// Init has been called or if the data is empty or sorted): +// +// !h.Less(j, i) for 0 <= i < h.Len() and 2*i+1 <= j <= 2*i+2 and j < h.Len() +// +// Note that Push and Pop in this interface are for package heap's +// implementation to call. To add and remove things from the heap, +// use heap.Push and heap.Pop. +type Interface interface { + sort.Interface + Push(x interface{}) // add x as element Len() + Pop() interface{} // remove and return element Len() - 1. +} + +// Init establishes the heap invariants required by the other routines in this package. +// Init is idempotent with respect to the heap invariants +// and may be called whenever the heap invariants may have been invalidated. +// The complexity is O(n) where n = h.Len(). +//read note 对整个Interface 进行重构，时间复杂度是 O(n) +func Init(h Interface) { + // heapify + n := h.Len() + //read note 从最小父节点，到第0位的根节点，分别向下进行重构处理(之所以要用循环是因为一次向下的重构，只能对一条连续的分支进行重构，不彻底.) + for i := n/2 - 1; i >= 0; i-- { + down(h, i, n) + } +} + +// Push pushes the element x onto the heap. +// The complexity is O(log n) where n = h.Len(). +// read note 这个Push方法是往 Interface里面去新增一个元素.和我们继承的Push方法有差别.这边同时候做了重构操作. +// 一次Push的时间复杂度是 O(logN),一次Init的时间复杂度是O(N),按道理Push的元素越多，Init的效率越高 +func Push(h Interface, x interface{}) { + //read note 先把元素添加进去 + h.Push(x) + //read note 然后在从下往上进行重构处理，正常情况下Push都是把元素添加在最后一个位置，如果实现的方法，把Push添加到其他位置如果不进行Init，应该是会有问题. + up(h, h.Len()-1) +} + +// Pop removes and returns the minimum element (according to Less) from the heap. +// The complexity is O(log n) where n = h.Len(). +// Pop is equivalent to Remove(h, 0). +//read note 把最小的元素输出，需要注意的是真正的Pop必须是调用这个方法，而不是我们继承的那个方法. +// 时间复杂度是O(logN) +func Pop(h Interface) interface{} { + //read note 真正的Pop输出的是最小的元素，也就是最小堆的第0位置的元素 + // 所以这边的操作是把第0位的数组放到最后一位，然后从位置0开始，到N-1的位置，对所有元素进行down(父子节点比较交换)的操作 + n := h.Len() - 1 + h.Swap(0, n) + down(h, 0, n) + return h.Pop() +} + +// Remove removes and returns the element at index i from the heap. +// The complexity is O(log n) where n = h.Len(). +//read note 移除某个位置的元素，时间复杂度是 o(logn) +func Remove(h Interface, i int) interface{} { + //read note 判断移除的下标不等于最后一个元素位置，要特殊处理 + n := h.Len() - 1 + if n != i { + //read note 交换第i个元素和最后一个元素 + h.Swap(i, n) + //read note Fix的处理操作，这边只会处理到移除一个元素后的位置，也就是说被移除的那个元素(在最后的位置)不会参与重构数组的操作 + if !down(h, i, n) { + up(h, i) + } + } + //read note 调用Pop，把最后一个元素返回回去 + return h.Pop() +} + +// Fix re-establishes the heap ordering after the element at index i has changed its value. +// Changing the value of the element at index i and then calling Fix is equivalent to, +// but less expensive than, calling Remove(h, i) followed by a Push of the new value. +// The complexity is O(log n) where n = h.Len(). +//read note 当下标为i的元素发生改变，需要进行一次Fix的处理,时间复杂度是 o(logn) +func Fix(h Interface, i int) { + //read note 想从下标i的这个元素往下查找处理，如果往下没有交换元素，再往上进行处理. + if !down(h, i, h.Len()) { + up(h, i) + } +} + +//read note h: 对应的数组数据 +//read note j:子节点的下标 +//read note 方法作用 +func up(h Interface, j int) { + for { + //read note 拿到对应的父节点的下标 + i := (j - 1) / 2 // parent + //read note 找到最后一个父节点 || 父节点比子节点小，则跳出循环 + if i == j || !h.Less(j, i) { + break + } + //read note 否则就是父节点比子节点的值大，需要交换对应的元素，然后找到父节点的下标，再往上找其父节点的关系 + h.Swap(i, j) + j = i + } +} + +//read note h: 对应的数组数据 +//read note i0: 需要下发处理的坐标，这边也就是左右子节点的父节点下标. +//read note n: 数组对应的总长度 +//read note 方法作用：从父节点开始，循环向下判断对应的元素是否在对应的环境上 +func down(h Interface, i0, n int) bool { + //read note 把父节点的下标拿出来 + i := i0 + + //read note 循环的结束条件是： + for { + //read note 找到左边子节点下标 + j1 := 2*i + 1 + //read note 退出条件1：超过最大长度或者是负值(这个应该是针对传入就有问题的处理) + if j1 >= n || j1 < 0 { // j1 < 0 after int overflow + break + } + //read note 拿到左孩子和右孩子中比较小的那个元素（的下标） + j := j1 // left child + if j2 := j1 + 1; j2 < n && h.Less(j2, j1) { + j = j2 // = 2*i + 2 // right child + } + + //read note 判断父节点和子节点的大小关系，小的元素应该在父节点，所以如果子节点本身就比较小，直接退出循环，否则交换元素 + //read note 然后再把下标移动到被交换的这个元素上，计算被交换的这个元素和它的左右子节点的大小关系，进入下一个循环 + if !h.Less(j, i) { + break + } + h.Swap(i, j) + i = j + } + //read note 判断是否发生了交换操作 + return i > i0 +} diff --git a/test/jdkContainer/SourceAnalysis/list.go b/test/jdkContainer/SourceAnalysis/list.go new file mode 100644 index 0000000..0afdff1 --- /dev/null +++ b/test/jdkContainer/SourceAnalysis/list.go @@ -0,0 +1,255 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package list implements a doubly linked list. +// +// To iterate over a list (where l is a *List): +// for e := l.Front(); e != nil; e = e.Next() { +// // do something with e.Value +// } +// +package SourceAnalysis + +// Element is an element of a linked list. +//read note list中对应的元素,list相当是通过一个链表来链接所有的Element元素. +type Element struct { + // Next and previous pointers in the doubly-linked list of elements. + // To simplify the implementation, internally a list l is implemented + // as a ring, such that &l.root is both the next element of the last + // list element (l.Back()) and the previous element of the first list + // element (l.Front()). + //read note 指向下一个和前一个元素的指针.internally a list l is implemented as a ring:内部实现实际是一个环 + next, prev *Element + + // The list to which this element belongs. + //read note 链表头，这边是设置表头为哨兵的模式进行链表的处理的 + list *List + + // The value stored with this element. + //read note Element中实际的元素值 + Value interface{} +} + +// Next returns the next list element or nil. +func (e *Element) Next() *Element { + //read note 获取下一个元素，这边判断条件包含 list不为空，以及next不为链表头结点（哨兵）. + if p := e.next; e.list != nil && p != &e.list.root { + return p + } + return nil +} + +// Prev returns the previous list element or nil. +func (e *Element) Prev() *Element { + //read note 与Next一样的道理，判断list不为空，以及pre不等于链表头结点 + if p := e.prev; e.list != nil && p != &e.list.root { + return p + } + return nil +} + +// List represents a doubly linked list. +// The zero value for List is an empty list ready to use. +//read note 设置哨兵的链表实现 +type List struct { + //read note 哨兵结点 + root Element // sentinel list element, only &root, root.prev, and root.next are used + //read note 链表长度 + len int // current list length excluding (this) sentinel element +} + +// Init initializes or clears list l. +func (l *List) Init() *List { + //read note 初始化的时候，链表的哨兵结点pre和next是互相指向的，这也可以作为判断链表是否为空的依据 + l.root.next = &l.root + l.root.prev = &l.root + l.len = 0 + return l +} + +// New returns an initialized list. +func New() *List { return new(List).Init() } + +// Len returns the number of elements of list l. +// The complexity is O(1). +func (l *List) Len() int { return l.len } + +// Front returns the first element of list l or nil if the list is empty. +// read note 返回第一个元素，如果链表不为空，则返回哨兵结点的next就是一个链表结点 +func (l *List) Front() *Element { + if l.len == 0 { + return nil + } + return l.root.next +} + +// Back returns the last element of list l or nil if the list is empty. +// read note 所以list是一个环，如果链表不为空，则最后一个元素可以通过哨兵的prev来获取到. +func (l *List) Back() *Element { + if l.len == 0 { + return nil + } + return l.root.prev +} + +// lazyInit lazily initializes a zero List value. +func (l *List) lazyInit() { + if l.root.next == nil { + l.Init() + } +} + +// insert inserts e after at, increments l.len, and returns e. +//read note 在某一个位置后面加入一个element,只需要设置一下长度，前后链表地址的指向即可。 +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 is a convenience wrapper for insert(&Element{Value: v}, at). +func (l *List) insertValue(v interface{}, at *Element) *Element { + return l.insert(&Element{Value: v}, at) +} + +// remove removes e from its list, decrements l.len, and returns e. +//read note 移除某个元素，返回该元素并设置不相关的属性为空，防止内存泄露. +func (l *List) remove(e *Element) *Element { + e.prev.next = e.next + e.next.prev = e.prev + e.next = nil // avoid memory leaks + e.prev = nil // avoid memory leaks + e.list = nil + l.len-- + return e +} + +// move moves e to next to at and returns e. +//read note 移动某个元素，本质上和插入某个元素有点类似.即移除对应节点后，再在对应的节点后面插入该元素 +func (l *List) move(e, at *Element) *Element { + if e == at { + return e + } + e.prev.next = e.next + e.next.prev = e.prev + + n := at.next + at.next = e + e.prev = at + e.next = n + n.prev = e + + return e +} + +// Remove removes e from l if e is an element of list l. +// It returns the element value e.Value. +// The element must not be nil. +func (l *List) Remove(e *Element) interface{} { + if e.list == l { + // if e.list == l, l must have been initialized when e was inserted + // in l or l == nil (e is a zero Element) and l.remove will crash + l.remove(e) + } + return e.Value +} + +// PushFront inserts a new element e with value v at the front of list l and returns e. +func (l *List) PushFront(v interface{}) *Element { + l.lazyInit() + return l.insertValue(v, &l.root) +} + +// PushBack inserts a new element e with value v at the back of list l and returns e. +func (l *List) PushBack(v interface{}) *Element { + l.lazyInit() + return l.insertValue(v, l.root.prev) +} + +// InsertBefore inserts a new element e with value v immediately before mark and returns e. +// If mark is not an element of l, the list is not modified. +// The mark must not be nil. +func (l *List) InsertBefore(v interface{}, mark *Element) *Element { + if mark.list != l { + return nil + } + // see comment in List.Remove about initialization of l + return l.insertValue(v, mark.prev) +} + +// InsertAfter inserts a new element e with value v immediately after mark and returns e. +// If mark is not an element of l, the list is not modified. +// The mark must not be nil. +func (l *List) InsertAfter(v interface{}, mark *Element) *Element { + if mark.list != l { + return nil + } + // see comment in List.Remove about initialization of l + return l.insertValue(v, mark) +} + +// MoveToFront moves element e to the front of list l. +// If e is not an element of l, the list is not modified. +// The element must not be nil. +func (l *List) MoveToFront(e *Element) { + if e.list != l || l.root.next == e { + return + } + // see comment in List.Remove about initialization of l + l.move(e, &l.root) +} + +// MoveToBack moves element e to the back of list l. +// If e is not an element of l, the list is not modified. +// The element must not be nil. +func (l *List) MoveToBack(e *Element) { + if e.list != l || l.root.prev == e { + return + } + // see comment in List.Remove about initialization of l + l.move(e, l.root.prev) +} + +// MoveBefore moves element e to its new position before mark. +// If e or mark is not an element of l, or e == mark, the list is not modified. +// The element and mark must not be nil. +func (l *List) MoveBefore(e, mark *Element) { + if e.list != l || e == mark || mark.list != l { + return + } + l.move(e, mark.prev) +} + +// MoveAfter moves element e to its new position after mark. +// If e or mark is not an element of l, or e == mark, the list is not modified. +// The element and mark must not be nil. +func (l *List) MoveAfter(e, mark *Element) { + if e.list != l || e == mark || mark.list != l { + return + } + l.move(e, mark) +} + +// PushBackList inserts a copy of an other list at the back of list l. +// The lists l and other may be the same. They must not be nil. +func (l *List) PushBackList(other *List) { + l.lazyInit() + for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() { + l.insertValue(e.Value, l.root.prev) + } +} + +// PushFrontList inserts a copy of an other list at the front of list l. +// The lists l and other may be the same. They must not be nil. +func (l *List) PushFrontList(other *List) { + l.lazyInit() + for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() { + l.insertValue(e.Value, &l.root) + } +} diff --git a/test/jdkContainer/SourceAnalysis/ring.go b/test/jdkContainer/SourceAnalysis/ring.go new file mode 100644 index 0000000..80b1036 --- /dev/null +++ b/test/jdkContainer/SourceAnalysis/ring.go @@ -0,0 +1,150 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package ring implements operations on circular lists. +package SourceAnalysis + +// A Ring is an element of a circular list, or ring. +// Rings do not have a beginning or end; a pointer to any ring element +// serves as reference to the entire ring. Empty rings are represented +// as nil Ring pointers. The zero value for a Ring is a one-element +// ring with a nil Value. +// +//read note 环结构:指针可能指向任意元素,空链表只有一个nil元素 +type Ring struct { + next, prev *Ring + Value interface{} // for use by client; untouched by this library +} + +//read note 初始化只是做了指针指向，不会增加环的值 +func (r *Ring) init() *Ring { + r.next = r + r.prev = r + return r +} + +// Next returns the next ring element. r must not be empty. +//read note：环的下一个值,如果环的next为空，则初始化该环 +func (r *Ring) Next() *Ring { + if r.next == nil { + return r.init() + } + return r.next +} + +// Prev returns the previous ring element. r must not be empty. +func (r *Ring) Prev() *Ring { + if r.next == nil { + return r.init() + } + return r.prev +} + +// Move moves n % r.Len() elements backward (n < 0) or forward (n >= 0) +// in the ring and returns that ring element. r must not be empty. +// +//read note 对环上的当前元素进行n次位置的移动，小于0则向后移动，大于0则向前移动 +func (r *Ring) Move(n int) *Ring { + if r.next == nil { + return r.init() + } + switch { + case n < 0: + for ; n < 0; n++ { + r = r.prev + } + case n > 0: + for ; n > 0; n-- { + r = r.next + } + } + return r +} + +// New creates a ring of n elements. +//read note 创建n个节点的环 +func New1(n int) *Ring { + if n <= 0 { + return nil + } + r := new(Ring) + p := r + for i := 1; i < n; i++ { + p.next = &Ring{prev: p} + p = p.next + } + p.next = r + r.prev = p + return r +} + +// Link connects ring r with ring s such that r.Next() +// becomes s and returns the original value for r.Next(). +// r must not be empty. +// +// If r and s point to the same ring, linking +// them removes the elements between r and s from the ring. +// The removed elements form a subring and the result is a +// reference to that subring (if no elements were removed, +// the result is still the original value for r.Next(), +// and not nil). +// +// If r and s point to different rings, linking +// them creates a single ring with the elements of s inserted +// after r. The result points to the element following the +// last element of s after insertion. +// +//read note 链接环，如果是两个相同的环则环不改变，链接完环会少掉原来的第一个元素....(神奇) +// 如果是两个不同的环，则把另一个环接到上一个环的后面，链接完的第一个元素是原来环的next的元素.第二个元素 +func (r *Ring) Link(s *Ring) *Ring { + n := r.Next() + if s != nil { + p := s.Prev() + // Note: Cannot use multiple assignment because + // evaluation order of LHS is not specified. + r.next = s + s.prev = r + n.prev = p + p.next = n + } + return n +} + +// Unlink removes n % r.Len() elements from the ring r, starting +// at r.Next(). If n % r.Len() == 0, r remains unchanged. +// The result is the removed subring. r must not be empty. +// +//read note 断开环上n个元素，这里会根据n%r.Len 得到的余数进行Unlink,因为环是没有起点终点的，所以超过或者不超过环的长度都是按照余数进行处理 +func (r *Ring) Unlink(n int) *Ring { + if n <= 0 { + return nil + } + return r.Link(r.Move(n + 1)) +} + +// Len computes the number of elements in ring r. +// It executes in time proportional to the number of elements. +// +func (r *Ring) Len() int { + n := 0 + if r != nil { + n = 1 + for p := r.Next(); p != r; p = p.next { + n++ + } + } + return n +} + +// Do calls function f on each element of the ring, in forward order. +// The behavior of Do is undefined if f changes *r. +//read note 对环上的所有元素进行函数操作,但是这边的操作好像是没办法改变环中的元素的,只能进行提取或者输出 +func (r *Ring) Do(f func(interface{})) { + if r != nil { + f(r.Value) + for p := r.Next(); p != r; p = p.next { + f(p.Value) + } + } +} diff --git a/test/jdkContainer/testHeap/HeapTool.go b/test/jdkContainer/testHeap/HeapTool.go new file mode 100644 index 0000000..3d3afc6 --- /dev/null +++ b/test/jdkContainer/testHeap/HeapTool.go @@ -0,0 +1,36 @@ +/* + * @Author : huangzj + * @Time : 2020/12/2 15:39 + * @Description： + */ + +package testHeap + +type Person struct { + Name string //名字 + Age int //年龄 + Money float64 //身价 +} + +type heapTool []*Person + +func (h *heapTool) Less(i, j int) bool { + return (*h)[i].Age < (*h)[j].Age +} + +func (h *heapTool) Swap(i, j int) { + (*h)[i], (*h)[j] = (*h)[j], (*h)[i] +} + +func (h *heapTool) Len() int { + return len(*h) +} + +func (h *heapTool) Pop() (v interface{}) { + *h, v = (*h)[:h.Len()-1], (*h)[h.Len()-1] + return +} + +func (h *heapTool) Push(v interface{}) { + *h = append(*h, v.(*Person)) +} diff --git a/test/jdkContainer/testHeap/heap_test.go b/test/jdkContainer/testHeap/heap_test.go new file mode 100644 index 0000000..7690a3b --- /dev/null +++ b/test/jdkContainer/testHeap/heap_test.go @@ -0,0 +1,62 @@ +/* + * @Author : huangzj + * @Time : 2020/12/2 11:19 + * @Description： + */ + +package testHeap + +import ( + "container/heap" + "fmt" + "testing" +) + +func TestHeapTool(t *testing.T) { + personList := new(heapTool) + personList.Push(&Person{ + Name: "小明", + Age: 20, + Money: 100000.99, + }) + personList.Push(&Person{ + Name: "小施", + Age: 30, + Money: 1002341.99, + }) + + personList.Push(&Person{ + Name: "小康", + Age: 10, + Money: 200.99, + }) + + personList.Push(&Person{ + Name: "老施", + Age: 50, + Money: 10343240000.99, + }) + + personList.Push(&Person{ + Name: "老康", + Age: 70, + Money: 10340.99, + }) + personList.Push(&Person{ + Name: "老明", + Age: 80, + Money: 13240000.99, + }) + personList.Push(&Person{ + Name: "老林", + Age: 90, + Money: 10340000.99, + }) + + heap.Init(personList) + for personList.Len() > 0 { + pop := heap.Pop(personList) + fmt.Println(fmt.Sprintf("%v,%v岁，资产：%v", pop.(*Person).Name, pop.(*Person).Age, pop.(*Person).Money)) + } + +} diff --git a/test/jdkContainer/testHeap/list_test.go b/test/jdkContainer/testHeap/list_test.go new file mode 100644 index 0000000..04d9bd9 --- /dev/null +++ b/test/jdkContainer/testHeap/list_test.go @@ -0,0 +1,69 @@ +/* + * @Author : huangzj + * @Time : 2020/12/3 21:58 + * @Description：测试list.go包的元素 + */ + +package testHeap + +import ( + "container/list" + "fmt" + "testing" +) + +func TestList(t *testing.T) { + list2 := list.New() + + list2.PushFront(Person{ + Name: "康康", + Age: 10, + Money: 20, + }) + + list2.PushBack(Person{ + Name: "老施", + Age: 40, + Money: 1000000, + }) + for e := list2.Front(); e != nil; e = e.Next() { + value := e.Value.(Person) + fmt.Println(fmt.Sprintf("名字：%v,年龄：%v，身家:%v", value.Name, value.Age, value.Money)) + } + fmt.Println() + fmt.Println() + + frontE := list2.Front() + list2.MoveToBack(frontE) + + for e := list2.Front(); e != nil; e = e.Next() { + value := e.Value.(Person) + fmt.Println(fmt.Sprintf("名字：%v,年龄：%v，身家:%v", value.Name, value.Age, value.Money)) + } + fmt.Println() + fmt.Println() + + xiaozhang := list2.InsertBefore(Person{ + Name: "小张", + Age: 10, + Money: 50, + }, list2.Front()) + for e := list2.Front(); e != nil; e = e.Next() { + value := e.Value.(Person) + fmt.Println(fmt.Sprintf("名字：%v,年龄：%v，身家:%v", value.Name, value.Age, value.Money)) + } + fmt.Println() + fmt.Println() + + list2.Remove(xiaozhang) + for e := list2.Front(); e != nil; e = e.Next() { + value := e.Value.(Person) + fmt.Println(fmt.Sprintf("名字：%v,年龄：%v，身家:%v", value.Name, value.Age, value.Money)) + } + fmt.Println() + fmt.Println() + + front := list2.Front().Value.(Person) + fmt.Println(fmt.Sprintf("名字：%v,年龄：%v，身家:%v", front.Name, front.Age, front.Money)) + +} diff --git a/test/jdkContainer/testHeap/ring_test.go b/test/jdkContainer/testHeap/ring_test.go new file mode 100644 index 0000000..7aa2586 --- /dev/null +++ b/test/jdkContainer/testHeap/ring_test.go @@ -0,0 +1,114 @@ +/* + * @Author : huangzj + * @Time : 2020/12/7 9:33 + * @Description： + */ + +package testHeap + +import ( + "container/ring" + "fmt" + "testing" +) + +func TestRing(t *testing.T) { + fmt.Println("测试空链表") + var rings ring.Ring + fmt.Println(rings.Next().Value) + + fmt.Println("") + fmt.Println("") + + fmt.Println("测试环") + newRing := makeN(10) + Print(newRing) + + fmt.Println("") + fmt.Println("") + fmt.Println("测试环Link自己") + newRing = makeN(10) + newRing = newRing.Link(newRing) + Print(newRing) + + fmt.Println() + fmt.Println() + fmt.Println("测试环Link其他环") + newRing = makeN(10) + newRing1 := makeN(5) + newRing = newRing.Link(newRing1) + Print(newRing) + + fmt.Println() + fmt.Println() + fmt.Println("测试Move") + newRing1 = makeN(5) + newRing1 = newRing1.Move(3) + Print(newRing1) + + fmt.Println() + fmt.Println() + fmt.Println("测试Do，没有办法改变环中的元素.") + newRing1 = makeN(5) + newRing1.Do(func(i interface{}) { + i = i.(int) + 1000 + }) + Print(newRing1) + + newRingx := ring.New(3) + for i := 1; i <= newRingx.Len(); i++ { + newRingx.Value = Person{ + Name: "小明", + Age: 100, + Money: 19999, + } + newRingx = newRingx.Next() + newRingx.Value = Person{ + Name: "小康", + Age: 50, + Money: 19921999, + } + newRingx = newRingx.Next() + newRingx.Value = Person{ + Name: "小施", + Age: 20, + Money: 1111999, + } + } + fmt.Println("测试Do，只能对元素进行提取或者输出.") + s := make([]int, 0) + newRingx.Do(func(i interface{}) { + s = append(s, i.(Person).Age) + }) + for _, item := range s { + fmt.Println(item) + } + + fmt.Println() + fmt.Println() + fmt.Println("测试Unlink") + newRing1 = makeN(5) + newRing2 := newRing1.Unlink(2) + Print(newRing1) + println() + fmt.Println("如果用赋值语句，可以返回被移除的元素") + Print(newRing2) +} + +func Print(r *ring.Ring) { + i, n := 0, r.Len() + for p := r; i < n; p = p.Next() { + fmt.Println(fmt.Sprintf("当前元素是%v", p.Value)) + i++ + } +} + +//创造对应的链表 +func makeN(n int) *ring.Ring { + r := ring.New(n) + for i := 1; i <= n; i++ { + r.Value = i + r = r.Next() + } + return r +}