save

list/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
+}

list/priority_list/priority_list.go

@@ -0,0 +1,165 @@
+package plist
+
+import (
+	"strings"
+
+	"github.com/474420502/focus/compare"
+	"github.com/davecgh/go-spew/spew"
+)
+
+type Node struct {
+	prev, next *Node
+	value      interface{}
+}
+
+type PriorityList struct {
+	head, tail *Node
+	size       int
+	Compare    compare.Compare
+}
+
+func New(Compare compare.Compare) *PriorityList {
+	pl := &PriorityList{head: &Node{}, tail: &Node{}, size: 0, Compare: Compare}
+	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) Size() int {
+	return pl.size
+}
+
+func (pl *PriorityList) Push(value interface{}) {
+	pl.size++
+	pnode := &Node{value: value}
+	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.Compare(value, 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) Top() (result interface{}, ok bool) {
+	if pl.size > 0 {
+		return pl.head.next.value, true
+	}
+	return nil, false
+}
+
+func (pl *PriorityList) Pop() (result interface{}, ok bool) {
+	if pl.size > 0 {
+		pl.size--
+		temp := pl.head.next
+		temp.next.prev = pl.head
+		pl.head.next = temp.next
+		return temp.value, true
+	}
+	return nil, false
+}
+
+func (pl *PriorityList) Get(idx int) (interface{}, bool) {
+	if n, ok := pl.GetNode(idx); ok {
+		return n.value, true
+	}
+	return nil, false
+}
+
+func (pl *PriorityList) GetNode(idx int) (*Node, bool) {
+	if idx >= 0 {
+		cur := pl.head.next
+		for i := 0; cur != pl.tail; i++ {
+			if i == idx {
+				return cur, true
+			}
+			cur = cur.next
+		}
+	} else {
+		cur := pl.tail.prev
+		for i := -1; cur != pl.head; i-- {
+			if i == idx {
+				return cur, true
+			}
+			cur = cur.prev
+		}
+	}
+	return nil, false
+}
+
+func (pl *PriorityList) RemoveWithIndex(idx int) {
+	if n, ok := pl.GetNode(idx); ok {
+		pl.Remove(n)
+	}
+}
+
+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
+}

list/priority_list/priority_list_test.go

@@ -0,0 +1,260 @@
+package plist
+
+import (
+	"bytes"
+	"encoding/gob"
+	"io/ioutil"
+	"log"
+	"testing"
+
+	"github.com/474420502/focus/compare"
+)
+
+func loadTestData() []int {
+	data, err := ioutil.ReadFile("../l.log")
+	if err != nil {
+		log.Println(err)
+	}
+	var l []int
+	decoder := gob.NewDecoder(bytes.NewReader(data))
+	decoder.Decode(&l)
+	return l
+}
+
+func TestInsert(t *testing.T) {
+	pl := New(compare.Int)
+	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(compare.Int)
+	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(compare.Int)
+	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(compare.Int)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	for _, v := range []int{0, 9, 5, 7} {
+		if g, ok := pl.Get(v); ok {
+			if g != (9 - v) {
+				t.Error(v, "Get == ", g)
+			}
+		}
+	}
+
+	if n, ok := pl.Get(10); ok {
+		t.Error("index 10  is over size", n)
+	}
+}
+
+func TestTop(t *testing.T) {
+	pl := New(compare.Int)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	i := 0
+	for n, ok := pl.Pop(); ok; n, ok = pl.Pop() {
+		if (9 - i) != n {
+			t.Error("value is not equal ", i)
+		}
+		if top, tok := pl.Top(); tok {
+			if (9 - i - 1) != top {
+				t.Error("top is error cur i = ", i, "top is ", top)
+			}
+		}
+
+		i++
+	}
+
+	if pl.Size() != 0 {
+		t.Error("list size is not zero")
+	}
+}
+
+func TestPop(t *testing.T) {
+	pl := New(compare.Int)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	i := 0
+	for n, ok := pl.Pop(); ok; n, ok = pl.Pop() {
+		if (9 - i) != n {
+			t.Error("value is not equal ", i)
+		}
+		i++
+	}
+
+	if pl.Size() != 0 {
+		t.Error("list size is not zero")
+	}
+
+	for i := 9; i >= 0; i-- {
+		pl.Push(i)
+	}
+
+	i = 0
+	for n, ok := pl.Pop(); ok; n, ok = pl.Pop() {
+		if (9 - i) != n {
+			t.Error("value is not equal ", i)
+		}
+		i++
+	}
+
+	if pl.Size() != 0 {
+		t.Error("list size is not zero")
+	}
+}
+
+func TestRemove(t *testing.T) {
+	pl := New(compare.Int)
+	for i := 0; i < 10; i++ {
+		pl.Push(i)
+	}
+
+	pl.RemoveWithIndex(0)
+	if g, ok := pl.Get(0); ok {
+		if g != 8 {
+			t.Error(g)
+		}
+	}
+
+	pl.RemoveWithIndex(-1)
+	if g, ok := pl.Get(-1); ok {
+		if g != 1 {
+			t.Error(g)
+		}
+	}
+
+}
+
+// func BenchmarkGet(b *testing.B) {
+// 	pl := New(compare.Int)
+
+// 	l := loadTestData()
+
+// 	for _, v := range l {
+// 		pl.Push(v)
+// 	}
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+// 	b.N = len(l)
+
+// 	for i := 0; i < b.N; i++ {
+// 		if i%2 == 0 {
+// 			pl.Get(i)
+// 		}
+// 	}
+
+// }
+// func BenchmarkInsert(b *testing.B) {
+
+// 	l := loadTestData()
+
+// 	b.ResetTimer()
+// 	b.StartTimer()
+
+// 	execCount := 1
+// 	b.N = len(l) * execCount
+// 	for i := 0; i < execCount; i++ {
+// 		pl := New(compare.Int)
+// 		for _, v := range l {
+// 			pl.Push(v)
+// 		}
+// 	}
+// }