少量测试通过版本

priority_list/iterator.go

@@ -0,0 +1,87 @@
+package plist
+
+type Iterator struct {
+	pl  *PriorityList
+	cur *Node
+}
+
+func (iter *Iterator) Value() interface{} {
+	return iter.cur.value
+}
+
+func (iter *Iterator) Prev() bool {
+	if iter.cur == iter.pl.head {
+		return false
+	}
+	iter.cur = iter.cur.prev
+	return iter.cur != iter.pl.head
+}
+
+func (iter *Iterator) Next() bool {
+	if iter.cur == iter.pl.tail {
+		return false
+	}
+	iter.cur = iter.cur.next
+	return iter.cur != iter.pl.tail
+}
+
+func (iter *Iterator) MoveToHead() {
+	iter.cur = iter.pl.head
+}
+
+func (iter *Iterator) MoveToTail() {
+	iter.cur = iter.pl.tail
+}
+
+type CircularIterator struct {
+	pl  *PriorityList
+	cur *Node
+}
+
+func (iter *CircularIterator) Value() interface{} {
+	return iter.cur.value
+}
+
+func (iter *CircularIterator) Prev() bool {
+	if iter.pl.size == 0 {
+		return false
+	}
+
+	if iter.cur == iter.pl.head {
+		iter.cur = iter.pl.tail.prev
+		return true
+	}
+
+	iter.cur = iter.cur.prev
+	if iter.cur == iter.pl.head {
+		iter.cur = iter.pl.tail.prev
+	}
+
+	return true
+}
+
+func (iter *CircularIterator) Next() bool {
+	if iter.pl.size == 0 {
+		return false
+	}
+
+	if iter.cur == iter.pl.tail {
+		iter.cur = iter.pl.head.next
+		return true
+	}
+
+	iter.cur = iter.cur.next
+	if iter.cur == iter.pl.tail {
+		iter.cur = iter.pl.head.next
+	}
+
+	return true
+}
+
+func (iter *CircularIterator) MoveToHead() {
+	iter.cur = iter.pl.head
+}
+
+func (iter *CircularIterator) MoveToTail() {
+	iter.cur = iter.pl.tail
+}

priority_list/priority_list.go

@@ -0,0 +1,138 @@
+package plist
+
+import (
+	"strings"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/emirpasic/gods/utils"
+)
+
+type Node struct {
+	prev, next *Node
+	value      interface{}
+}
+
+type PriorityList struct {
+	head, tail *Node
+	size       int
+	comparator utils.Comparator
+}
+
+func New(compartor utils.Comparator) *PriorityList {
+	pl := &PriorityList{head: &Node{}, tail: &Node{}, size: 0, comparator: compartor}
+	pl.head.next = pl.tail
+	pl.tail.prev = pl.head
+	return pl
+}
+
+func (pl *PriorityList) String() string {
+	content := ""
+
+	cur := pl.head.next
+
+	for ; cur != pl.tail; cur = cur.next {
+		content += spew.Sprint(cur.value) + " "
+	}
+	content = strings.TrimRight(content, " ")
+	return content
+}
+
+func (pl *PriorityList) RString() string {
+	content := ""
+
+	cur := pl.tail.prev
+
+	for ; cur != pl.head; cur = cur.prev {
+		content += spew.Sprint(cur.value) + " "
+	}
+	content = strings.TrimRight(content, " ")
+	return content
+}
+
+func (pl *PriorityList) Iterator() *Iterator {
+	return &Iterator{pl: pl, cur: pl.head}
+}
+
+func (pl *PriorityList) CircularIterator() *CircularIterator {
+	return &CircularIterator{pl: pl, cur: pl.head}
+}
+
+func (pl *PriorityList) Push(pvalue interface{}) {
+	pl.size++
+	pnode := &Node{value: pvalue}
+	if pl.size == 1 {
+		pl.head.next = pnode
+		pl.tail.prev = pnode
+		pnode.prev = pl.head
+		pnode.next = pl.tail
+		return
+	}
+
+	cur := pl.head
+	for ; cur.next != pl.tail; cur = cur.next {
+		if pl.comparator(pvalue, cur.next.value) > 0 {
+			cnext := cur.next
+
+			cur.next = pnode
+			cnext.prev = pnode
+			pnode.prev = cur
+			pnode.next = cnext
+
+			return
+		}
+	}
+
+	cur.next = pnode
+	pnode.prev = cur
+	pnode.next = pl.tail
+	pl.tail.prev = pnode
+}
+
+func (pl *PriorityList) Get(idx int) interface{} {
+	return pl.GetNode(idx).value
+}
+
+func (pl *PriorityList) GetNode(idx int) *Node {
+	if idx >= 0 {
+		cur := pl.head.next
+		for i := 0; cur != pl.tail; i++ {
+			if i == idx {
+				return cur
+			}
+			cur = cur.next
+		}
+	} else {
+		cur := pl.tail.prev
+		for i := -1; cur != pl.head; i-- {
+			if i == idx {
+				return cur
+			}
+			cur = cur.prev
+		}
+	}
+	return nil
+}
+
+func (pl *PriorityList) RemoveWithIndex(idx int) {
+	pl.Remove(pl.GetNode(idx))
+}
+
+func (pl *PriorityList) Remove(node *Node) {
+
+	prev := node.prev
+	next := node.next
+	prev.next = next
+	next.prev = prev
+
+	node.prev = nil
+	node.next = nil
+
+	pl.size--
+}
+func (pl *PriorityList) Values() []interface{} {
+	values := make([]interface{}, pl.size, pl.size)
+	for i, cur := 0, pl.head.next; cur != pl.tail; i, cur = i+1, cur.next {
+		values[i] = cur.value
+	}
+	return values
+}

priority_list/priority_list_test.go

@@ -0,0 +1,148 @@
+package plist
+
+import (
+	"testing"
+
+	"github.com/emirpasic/gods/utils"
+)
+
+func TestInsert(t *testing.T) {
+	pl := New(utils.IntComparator)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	if pl.size != 10 {
+		t.Error(pl.size)
+	}
+
+	if pl.String() != "9 8 7 6 5 4 3 2 1 0" {
+		t.Error(pl.String())
+	}
+
+	if pl.RString() != "0 1 2 3 4 5 6 7 8 9" {
+		t.Error(pl.RString())
+	}
+
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	if pl.String() != "9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 0 0" {
+		t.Error(pl.String())
+	}
+
+	if pl.RString() != "0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9" {
+		t.Error(pl.RString())
+	}
+}
+
+func TestIterator(t *testing.T) {
+	pl := New(utils.IntComparator)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	iter := pl.Iterator()
+
+	for i := 0; iter.Next(); i++ {
+		if iter.Value() != 9-i {
+			t.Error("iter.Next() ", iter.Value(), "is not equal ", 9-i)
+		}
+	}
+
+	if iter.cur != iter.pl.tail {
+		t.Error("current point is not equal tail ", iter.pl.tail)
+	}
+
+	for i := 0; iter.Prev(); i++ {
+		if iter.Value() != i {
+			t.Error("iter.Prev() ", iter.Value(), "is not equal ", i)
+		}
+	}
+}
+
+func TestCircularIterator(t *testing.T) {
+	pl := New(utils.IntComparator)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	iter := pl.CircularIterator()
+
+	for i := 0; i != 10; i++ {
+		iter.Next()
+		if iter.Value() != 9-i {
+			t.Error("iter.Next() ", iter.Value(), "is not equal ", 9-i)
+		}
+	}
+
+	if iter.cur != iter.pl.tail.prev {
+		t.Error("current point is not equal tail ", iter.pl.tail.prev)
+	}
+
+	if iter.Next() {
+		if iter.Value() != 9 {
+			t.Error("iter.Value() != ", iter.Value())
+		}
+	}
+
+	iter.MoveToTail()
+	for i := 0; i != 10; i++ {
+		iter.Prev()
+		if iter.Value() != i {
+			t.Error("iter.Prev() ", iter.Value(), "is not equal ", i)
+		}
+	}
+
+	if iter.cur != iter.pl.head.next {
+		t.Error("current point is not equal tail ", iter.pl.tail.prev)
+	}
+
+	if iter.Prev() {
+		if iter.Value() != 0 {
+			t.Error("iter.Value() != ", iter.Value())
+		}
+	}
+}
+
+func TestGet(t *testing.T) {
+	pl := New(utils.IntComparator)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	for _, v := range []int{0, 9, 5, 7} {
+		if pl.Get(v) != (9 - v) {
+			t.Error(v, "Get == ", pl.Get(v))
+		}
+	}
+
+	func() {
+		defer func() {
+			if err := recover(); err == nil {
+				t.Error("out index, but is not error")
+			}
+		}()
+
+		pl.Get(10)
+	}()
+}
+
+func TestRemove(t *testing.T) {
+	pl := New(utils.IntComparator)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	pl.RemoveWithIndex(0)
+	if pl.Get(0).(int) != 8 {
+		t.Error(pl.Get(0))
+	}
+
+	pl.RemoveWithIndex(-1)
+	if pl.Get(-1).(int) != 1 {
+		t.Error(pl.Get(-1))
+	}
+
+}