eson/focus
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

new file: .gitignore

Browse Source 
new file:   LICENSE
new file:   README.md
new file:   compare/compare.go
new file:   for_test.go
new file:   heap/heap.go
new file:   heap/heap_test.go
new file:   interface.go
new file:   lastack/lastack.go
new file:   lastack/lastack_test.go
new file:   list/list.go
new file:   list/list_test.go
new file:   map/hashmap/hashmap.go
new file:   map/hashmap/hashmap_test.go
new file:   priority_list/iterator.go
new file:   priority_list/priority_list.go
new file:   priority_list/priority_list_test.go
new file:   priority_queue/iterator.go
new file:   priority_queue/priority_queue.go
new file:   priority_queue/priority_queue_test.go
new file:   priority_queue/vbt.go
new file:   priority_queue/vbt_test.go
new file:   priority_queuekey/iterator.go
new file:   priority_queuekey/priority_queuekey.go
new file:   priority_queuekey/priority_queuekey_test.go
new file:   priority_queuekey/vbt.go
new file:   priority_queuekey/vbt_test.go
new file:   set/hashset/hashset.go
new file:   set/hashset/hashset_test.go
new file:   set/treeset/treeset.go
new file:   set/treeset/treeset_test.go
new file:   sparse_array/array2/array2.go
new file:   sparse_array/array2/array2_test.go
new file:   sparse_array/array3/array3.go
new file:   sparse_array/array3/array3_test.go
new file:   sparse_array/arrayn/arrayn.go
new file:   sparse_array/arrayn/arrayn_test.go
new file:   stack/stack.go
new file:   stack/stack_test.go
new file:   tree/avl/avl.go
new file:   tree/avl/avl_test.go
new file:   tree/avl/iterator.go
new file:   tree/avldup/avldup.go
new file:   tree/avldup/avldup_test.go
new file:   tree/avldup/iterator.go
new file:   tree/avlkey/avlkey.go
new file:   tree/avlkey/avlkey_test.go
new file:   tree/avlkey/iterator.go
new file:   tree/avlkeydup/avlkeydup.go
new file:   tree/avlkeydup/avlkeydup_test.go
new file:   tree/avlkeydup/iterator.go
new file:   tree/vbt/iterator.go
new file:   tree/vbt/vbt.go
new file:   tree/vbt/vbt_test.go
new file:   tree/vbtkey/iterator.go
new file:   tree/vbtkey/vbtkey.go
new file:   tree/vbtkey/vbtkey_test.go
This commit is contained in:
eson
2019-05-08 10:42:51 +08:00
commit 368447c31d
57 changed files with 18364 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
priority_list/iterator.go Normal file
View File

@@ -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
}

165
priority_list/priority_list.go Normal file
View File

@@ -0,0 +1,165 @@
package plist
import (
"strings"
"474420502.top/eson/structure/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
}

260
priority_list/priority_list_test.go Normal file
View File

@@ -0,0 +1,260 @@
package plist
import (
"bytes"
"encoding/gob"
"io/ioutil"
"log"
"testing"
"474420502.top/eson/structure/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)
}
}
}