From 5d99146aec1d5b8152b704a86bd4dd887e5771bf Mon Sep 17 00:00:00 2001 From: huangsimin Date: Wed, 13 Feb 2019 16:47:11 +0800 Subject: [PATCH 1/6] =?UTF-8?q?=E5=9F=BA=E7=A1=80=E5=8D=95=E7=B4=A2?= =?UTF-8?q?=E5=BC=95=E4=BC=98=E5=85=88=E9=98=9F=E5=88=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- priority_queue/priority_queue.go | 105 ++++++++++++++------------ priority_queue/priority_queue_test.go | 33 ++++---- 2 files changed, 72 insertions(+), 66 deletions(-) diff --git a/priority_queue/priority_queue.go b/priority_queue/priority_queue.go index fea7759..f99aa14 100644 --- a/priority_queue/priority_queue.go +++ b/priority_queue/priority_queue.go @@ -7,8 +7,11 @@ import ( // PriorityQueue 优先队列 适合数据量不大, 加索引 type PriorityQueue struct { - index *Index + index *Index + indexlimit int + spanlimit int + node *Node size int comparator utils.Comparator @@ -17,12 +20,12 @@ type PriorityQueue struct { type Index struct { node *Node next *Index + nlen int } type Node struct { value interface{} - // prev *Node next *Node } @@ -43,14 +46,6 @@ func NewWithInt() *PriorityQueue { func (pq *PriorityQueue) String() string { content := "" for cur := pq.node; cur != nil; cur = cur.next { - // var prevcontent string - // if cur.prev != nil { - // prevcontent = "(" + spew.Sprint(cur.prev.value) + "<-)" - // } else { - // prevcontent = "(nil)" - // } - - // content += spew.Sprint(cur.value) + prevcontent + "-" content += spew.Sprint(cur.value) + "-" } @@ -68,27 +63,10 @@ func (pq *PriorityQueue) String() string { return content + "\n" + idxContent } -func (pq *PriorityQueue) Push(v interface{}) { - - node := new(Node) - node.value = v - - if pq.node == nil { - //创建索引 - index := new(Index) - index.nlen = 1 - index.node = node - - pq.index = index - pq.node = node - - return - } +func (pq *PriorityQueue) findIndexStart(v interface{}) *Index { // find the node of index to start idx := pq.index - for { - if idx.next == nil { break } @@ -99,29 +77,72 @@ func (pq *PriorityQueue) Push(v interface{}) { idx = idx.next } + return idx +} + +func (pq *PriorityQueue) Get(index int) (interface{}, bool) { + if index < 0 || index >= pq.size { + return nil, false + } + + idx := pq.index + movesize := index + for { + if movesize-idx.nlen <= 0 { + break + } else { + movesize -= idx.nlen + idx = idx.next + } + } + cur := idx.node + for movesize > 0 { + movesize-- + cur = cur.next + } + + return cur.value, true +} + +func (pq *PriorityQueue) Push(v interface{}) { + + node := new(Node) + node.value = v + pq.size++ + + if pq.node == nil { + //创建索引 + index := new(Index) + index.nlen = 1 + index.node = node + + pq.index = index + pq.node = node + return + } + // find the node of index to start + idx := pq.findIndexStart(v) cur := idx.node - //cur := pq.node if pq.comparator(v, pq.node.value) > 0 { pq.node = node node.next = cur pq.index.node = pq.node pq.index.nlen++ - - // cur.prev = node return } for i := 0; cur.next != nil; i++ { - if i >= pq.indexlimit { if idx.next != nil && idx.next.nlen < pq.indexlimit { idx.next.nlen += idx.nlen - pq.indexlimit idx.nlen = pq.indexlimit idx.next.node = cur + idx = idx.next + i = 0 } else { index := new(Index) index.node = cur @@ -133,41 +154,27 @@ func (pq *PriorityQueue) Push(v interface{}) { idx = index i = 0 } - } if pq.comparator(v, cur.next.value) > 0 { temp := cur.next cur.next = node node.next = temp - // node.prev = cur - // temp.prev = node - idx.nlen++ - - // if pq.index.nlen >= pq.indexlimit { - // // 分裂 - - // } - return } - cur = cur.next } cur.next = node - - // node.prev = cur - pq.size++ idx.nlen++ } -// func (pq *PriorityQueue) Top() (interface{}, bool) { -// return pq.Get(0) -// } +func (pq *PriorityQueue) Top() (interface{}, bool) { + return pq.Get(0) +} // func (pq *PriorityQueue) Bottom() (interface{}, bool) { // return pq.Get(pq.right - 1) diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go index 2a88264..566e394 100644 --- a/priority_queue/priority_queue_test.go +++ b/priority_queue/priority_queue_test.go @@ -1,7 +1,6 @@ package plist import ( - "log" "testing" "github.com/emirpasic/gods/utils" @@ -11,30 +10,30 @@ import ( "github.com/emirpasic/gods/trees/binaryheap" ) -type PriorityQ struct { - heap *binaryheap.Heap - comparator utils.Comparator - topk int - next *PriorityQ -} - -func (pq *PriorityQ) Push(v interface{}) { -} - -func TestNPQ(t *testing.T) { - h1 := binaryheap.NewWithIntComparator() +func TestGetPriorityQueue(t *testing.T) { + p := NewWithInt() + var l []int for i := 0; i < 10; i++ { - h1.Push(i) + l = append(l, randomdata.Number(0, 10000)) } - h1.Values()[0] = 3 + for _, v := range l { + p.Push(v) + t.Log(p.String()) + } - log.Println(h1) + t.Error(l) + t.Error(p.String()) + + for _, i := range []int{-1, 0, p.size / 2, p.size - 1, p.size} { + v, ok := p.Get(i) + t.Error(i, v, ok) + } } -func TestPriorityQueue(t *testing.T) { +func TestPustPriorityQueue(t *testing.T) { p := NewWithInt() for i := 0; i < 100; i++ { From cd40d47a3c1708205b088fbfeb3f62f9586902ae Mon Sep 17 00:00:00 2001 From: huangsimin Date: Wed, 13 Feb 2019 18:02:01 +0800 Subject: [PATCH 2/6] =?UTF-8?q?TODO:=20=E5=AE=8C=E5=96=84avl=E7=B4=A2?= =?UTF-8?q?=E5=BC=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- priority_queue/priority_queue.go | 24 ++++++------ priority_queue/priority_queue_test.go | 53 ++++++++++++++++++++++++++- 2 files changed, 62 insertions(+), 15 deletions(-) diff --git a/priority_queue/priority_queue.go b/priority_queue/priority_queue.go index f99aa14..5d6e305 100644 --- a/priority_queue/priority_queue.go +++ b/priority_queue/priority_queue.go @@ -2,28 +2,20 @@ package plist import ( "github.com/davecgh/go-spew/spew" + "github.com/emirpasic/gods/trees/avltree" "github.com/emirpasic/gods/utils" ) // PriorityQueue 优先队列 适合数据量不大, 加索引 type PriorityQueue struct { - index *Index - + avlIndex *avltree.Tree indexlimit int - spanlimit int node *Node size int comparator utils.Comparator } -type Index struct { - node *Node - next *Index - - nlen int -} - type Node struct { value interface{} // prev *Node @@ -33,13 +25,17 @@ type Node struct { // NewWithInt compare use int func NewWithInt() *PriorityQueue { p := new(PriorityQueue) - p.indexlimit = 10 + p.comparator = func(a, b interface{}) int { if a.(int) > b.(int) { return 1 } return -1 } + + p.indexlimit = 10 + p.avlIndex = avltree.NewWith(p.comparator) + return p } @@ -135,6 +131,8 @@ func (pq *PriorityQueue) Push(v interface{}) { } for i := 0; cur.next != nil; i++ { + + // 分裂和整理索引 if i >= pq.indexlimit { if idx.next != nil && idx.next.nlen < pq.indexlimit { @@ -142,7 +140,6 @@ func (pq *PriorityQueue) Push(v interface{}) { idx.nlen = pq.indexlimit idx.next.node = cur idx = idx.next - i = 0 } else { index := new(Index) index.node = cur @@ -152,8 +149,9 @@ func (pq *PriorityQueue) Push(v interface{}) { idx.next = index idx.nlen = pq.indexlimit idx = index - i = 0 } + + i = 0 } if pq.comparator(v, cur.next.value) > 0 { diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go index 566e394..0765dd3 100644 --- a/priority_queue/priority_queue_test.go +++ b/priority_queue/priority_queue_test.go @@ -3,6 +3,8 @@ package plist import ( "testing" + "github.com/emirpasic/gods/trees/avltree" + "github.com/emirpasic/gods/utils" "github.com/Pallinder/go-randomdata" @@ -44,7 +46,7 @@ func TestPustPriorityQueue(t *testing.T) { t.Error(p.String()) } -func BenchmarkPriorityQueue(b *testing.B) { +func BenchmarkPriorityQueuePush(b *testing.B) { p := NewWithInt() // for i := 0; i < 10000; i++ { @@ -52,14 +54,61 @@ func BenchmarkPriorityQueue(b *testing.B) { // // p.Values() // } - b.N = 100000 + b.N = 10000 for i := 0; i < b.N; i++ { p.Push(randomdata.Number(0, 100000)) } } +func BenchmarkPriorityQueueGet(b *testing.B) { + p := NewWithInt() + + for i := 0; i < 10000; i++ { + p.Push(randomdata.Number(0, 100000)) + // p.Values() + } + + b.StartTimer() + b.N = 100000 + for i := 0; i < b.N; i++ { + p.Get(randomdata.Number(0, 10000)) + } + b.StopTimer() + +} + +func TestAVL(t *testing.T) { + avl := avltree.NewWithIntComparator() + for i := 0; i < 10; i++ { + v := randomdata.Number(0, 10) + avl.Put(v, v) + } + t.Error(avl.Values()) + f, ok := avl.Ceiling(100) + t.Error(f, ok) + t.Error(f.Next().Value) +} + +func BenchmarkAVL(b *testing.B) { + avl := avltree.NewWithIntComparator() + b.N = 1000000 + + b.StartTimer() + for i := 0; i < b.N; i++ { + v := randomdata.Number(0, 100000000) + avl.Put(v, v) + } + + for i := 0; i < b.N; i++ { + avl.Get(i) + } + + b.StopTimer() +} + func TestHeap(t *testing.T) { + heap := binaryheap.NewWithIntComparator() for i := 0; i < 10; i++ { From b5498a257b30b225622544e63d49a62ef782bc8e Mon Sep 17 00:00:00 2001 From: huangsimin Date: Wed, 13 Feb 2019 18:54:03 +0800 Subject: [PATCH 3/6] =?UTF-8?q?put=20=E4=BF=AE=E6=94=B9=E4=B8=BAput?= =?UTF-8?q?=E5=90=8E=E8=BF=94=E5=9B=9Eput=E7=9A=84=E8=8A=82=E7=82=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- priority_queue/avltree.go | 455 ++++++++++++++++++++++++++ priority_queue/iterator.go | 117 +++++++ priority_queue/priority_queue.go | 181 +++++----- priority_queue/priority_queue_test.go | 123 +++---- 4 files changed, 714 insertions(+), 162 deletions(-) create mode 100644 priority_queue/avltree.go create mode 100644 priority_queue/iterator.go diff --git a/priority_queue/avltree.go b/priority_queue/avltree.go new file mode 100644 index 0000000..4d80061 --- /dev/null +++ b/priority_queue/avltree.go @@ -0,0 +1,455 @@ +// Copyright (c) 2017, Benjamin Scher Purcell. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package avltree implements an AVL balanced binary tree. +// +// Structure is not thread safe. +// +// References: https://en.wikipedia.org/wiki/AVL_tree +package plist + +import ( + "fmt" + + "github.com/emirpasic/gods/trees" + "github.com/emirpasic/gods/utils" +) + +func assertTreeImplementation() { + var _ trees.Tree = new(Tree) +} + +// Tree holds elements of the AVL tree. +type Tree struct { + Root *ANode // Root node + Comparator utils.Comparator // Key comparator + size int // Total number of keys in the tree +} + +// ANode is a single element within the tree +type ANode struct { + Key interface{} + Value interface{} + Parent *ANode // Parent node + Children [2]*ANode // Children nodes + b int8 +} + +// NewWith instantiates an AVL tree with the custom comparator. +func NewWith(comparator utils.Comparator) *Tree { + return &Tree{Comparator: comparator} +} + +// NewWithIntComparator instantiates an AVL tree with the IntComparator, i.e. keys are of type int. +func NewWithIntComparator() *Tree { + return &Tree{Comparator: utils.IntComparator} +} + +// NewWithStringComparator instantiates an AVL tree with the StringComparator, i.e. keys are of type string. +func NewWithStringComparator() *Tree { + return &Tree{Comparator: utils.StringComparator} +} + +// Put inserts node into the tree. +// Key should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Put(key interface{}, value interface{}) (bool, *ANode) { + return t.put(key, value, nil, &t.Root) +} + +// Get searches the node in the tree by key and returns its value or nil if key is not found in tree. +// Second return parameter is true if key was found, otherwise false. +// Key should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Get(key interface{}) (value interface{}, found bool) { + n := t.Root + for n != nil { + cmp := t.Comparator(key, n.Key) + switch { + case cmp == 0: + return n.Value, true + case cmp < 0: + n = n.Children[0] + case cmp > 0: + n = n.Children[1] + } + } + return nil, false +} + +// Remove remove the node from the tree by key. +// Key should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Remove(key interface{}) { + t.remove(key, &t.Root) +} + +// Empty returns true if tree does not contain any nodes. +func (t *Tree) Empty() bool { + return t.size == 0 +} + +// Size returns the number of elements stored in the tree. +func (t *Tree) Size() int { + return t.size +} + +// Keys returns all keys in-order +func (t *Tree) Keys() []interface{} { + keys := make([]interface{}, t.size) + it := t.Iterator() + for i := 0; it.Next(); i++ { + keys[i] = it.Key() + } + return keys +} + +// Values returns all values in-order based on the key. +func (t *Tree) Values() []interface{} { + values := make([]interface{}, t.size) + it := t.Iterator() + for i := 0; it.Next(); i++ { + values[i] = it.Value() + } + return values +} + +// Left returns the minimum element of the AVL tree +// or nil if the tree is empty. +func (t *Tree) Left() *ANode { + return t.bottom(0) +} + +// Right returns the maximum element of the AVL tree +// or nil if the tree is empty. +func (t *Tree) Right() *ANode { + return t.bottom(1) +} + +// Floor Finds floor node of the input key, return the floor node or nil if no ceiling is found. +// Second return parameter is true if floor was found, otherwise false. +// +// Floor node is defined as the largest node that is smaller than or equal to the given node. +// A floor node may not be found, either because the tree is empty, or because +// all nodes in the tree is larger than the given node. +// +// Key should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Floor(key interface{}) (floor *ANode, found bool) { + found = false + n := t.Root + last := n + + for n != nil { + c := t.Comparator(key, n.Key) + switch { + case c == 0: + return n, true + case c < 0: + last = n + n = n.Children[0] + case c > 0: + floor, found = n, true + n = n.Children[1] + } + } + if found { + return + } + return last, false +} + +// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling is found. +// Second return parameter is true if ceiling was found, otherwise false. +// +// Ceiling node is defined as the smallest node that is larger than or equal to the given node. +// A ceiling node may not be found, either because the tree is empty, or because +// all nodes in the tree is smaller than the given node. +// +// Key should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Ceiling(key interface{}) (floor *ANode, found bool) { + found = false + n := t.Root + last := n + for n != nil { + c := t.Comparator(key, n.Key) + switch { + case c == 0: + return n, true + case c < 0: + floor, found = n, true + n = n.Children[0] + case c > 0: + last = n + n = n.Children[1] + } + } + if found { + return + } + return last, false +} + +// Clear removes all nodes from the tree. +func (t *Tree) Clear() { + t.Root = nil + t.size = 0 +} + +// String returns a string representation of container +func (t *Tree) String() string { + str := "AVLTree\n" + if !t.Empty() { + output(t.Root, "", true, &str) + } + return str +} + +func (n *ANode) String() string { + return fmt.Sprintf("%v", n.Key) +} + +func (t *Tree) put(key interface{}, value interface{}, p *ANode, qp **ANode) (bool, *ANode) { + q := *qp + if q == nil { + t.size++ + *qp = &ANode{Key: key, Value: value, Parent: p} + return true, *qp + } + + c := t.Comparator(key, q.Key) + if c == 0 { + q.Key = key + q.Value = value + return false, q + } + + if c < 0 { + c = -1 + } else { + c = 1 + } + a := (c + 1) / 2 + var fix bool + fix, node := t.put(key, value, q, &q.Children[a]) + if fix { + return putFix(int8(c), qp), *qp + } + return false, q +} + +func (t *Tree) remove(key interface{}, qp **ANode) bool { + q := *qp + if q == nil { + return false + } + + c := t.Comparator(key, q.Key) + if c == 0 { + t.size-- + if q.Children[1] == nil { + if q.Children[0] != nil { + q.Children[0].Parent = q.Parent + } + *qp = q.Children[0] + return true + } + fix := removeMin(&q.Children[1], &q.Key, &q.Value) + if fix { + return removeFix(-1, qp) + } + return false + } + + if c < 0 { + c = -1 + } else { + c = 1 + } + a := (c + 1) / 2 + fix := t.remove(key, &q.Children[a]) + if fix { + return removeFix(int8(-c), qp) + } + return false +} + +func removeMin(qp **ANode, minKey *interface{}, minVal *interface{}) bool { + q := *qp + if q.Children[0] == nil { + *minKey = q.Key + *minVal = q.Value + if q.Children[1] != nil { + q.Children[1].Parent = q.Parent + } + *qp = q.Children[1] + return true + } + fix := removeMin(&q.Children[0], minKey, minVal) + if fix { + return removeFix(1, qp) + } + return false +} + +func putFix(c int8, t **ANode) bool { + s := *t + if s.b == 0 { + s.b = c + return true + } + + if s.b == -c { + s.b = 0 + return false + } + + if s.Children[(c+1)/2].b == c { + s = singlerot(c, s) + } else { + s = doublerot(c, s) + } + *t = s + return false +} + +func removeFix(c int8, t **ANode) bool { + s := *t + if s.b == 0 { + s.b = c + return false + } + + if s.b == -c { + s.b = 0 + return true + } + + a := (c + 1) / 2 + if s.Children[a].b == 0 { + s = rotate(c, s) + s.b = -c + *t = s + return false + } + + if s.Children[a].b == c { + s = singlerot(c, s) + } else { + s = doublerot(c, s) + } + *t = s + return true +} + +func singlerot(c int8, s *ANode) *ANode { + s.b = 0 + s = rotate(c, s) + s.b = 0 + return s +} + +func doublerot(c int8, s *ANode) *ANode { + a := (c + 1) / 2 + r := s.Children[a] + s.Children[a] = rotate(-c, s.Children[a]) + p := rotate(c, s) + + switch { + default: + s.b = 0 + r.b = 0 + case p.b == c: + s.b = -c + r.b = 0 + case p.b == -c: + s.b = 0 + r.b = c + } + + p.b = 0 + return p +} + +func rotate(c int8, s *ANode) *ANode { + a := (c + 1) / 2 + r := s.Children[a] + s.Children[a] = r.Children[a^1] + if s.Children[a] != nil { + s.Children[a].Parent = s + } + r.Children[a^1] = s + r.Parent = s.Parent + s.Parent = r + return r +} + +func (t *Tree) bottom(d int) *ANode { + n := t.Root + if n == nil { + return nil + } + + for c := n.Children[d]; c != nil; c = n.Children[d] { + n = c + } + return n +} + +// Prev returns the previous element in an inorder +// walk of the AVL tree. +func (n *ANode) Prev() *ANode { + return n.walk1(0) +} + +// Next returns the next element in an inorder +// walk of the AVL tree. +func (n *ANode) Next() *ANode { + return n.walk1(1) +} + +func (n *ANode) walk1(a int) *ANode { + if n == nil { + return nil + } + + if n.Children[a] != nil { + n = n.Children[a] + for n.Children[a^1] != nil { + n = n.Children[a^1] + } + return n + } + + p := n.Parent + for p != nil && p.Children[a] == n { + n = p + p = p.Parent + } + return p +} + +func output(node *ANode, prefix string, isTail bool, str *string) { + if node.Children[1] != nil { + newPrefix := prefix + if isTail { + newPrefix += "│ " + } else { + newPrefix += " " + } + output(node.Children[1], newPrefix, false, str) + } + *str += prefix + if isTail { + *str += "└── " + } else { + *str += "┌── " + } + *str += node.String() + "\n" + if node.Children[0] != nil { + newPrefix := prefix + if isTail { + newPrefix += " " + } else { + newPrefix += "│ " + } + output(node.Children[0], newPrefix, true, str) + } +} diff --git a/priority_queue/iterator.go b/priority_queue/iterator.go new file mode 100644 index 0000000..da9d9cb --- /dev/null +++ b/priority_queue/iterator.go @@ -0,0 +1,117 @@ +// Copyright (c) 2017, Benjamin Scher Purcell. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package plist + +import "github.com/emirpasic/gods/containers" + +func assertIteratorImplementation() { + var _ containers.ReverseIteratorWithKey = (*Iterator)(nil) +} + +// Iterator holding the iterator's state +type Iterator struct { + tree *Tree + node *ANode + position position +} + +type position byte + +const ( + begin, between, end position = 0, 1, 2 +) + +// Iterator returns a stateful iterator whose elements are key/value pairs. +func (tree *Tree) Iterator() containers.ReverseIteratorWithKey { + return &Iterator{tree: tree, node: nil, position: begin} +} + +// Next moves the iterator to the next element and returns true if there was a next element in the container. +// If Next() returns true, then next element's key and value can be retrieved by Key() and Value(). +// If Next() was called for the first time, then it will point the iterator to the first element if it exists. +// Modifies the state of the iterator. +func (iterator *Iterator) Next() bool { + switch iterator.position { + case begin: + iterator.position = between + iterator.node = iterator.tree.Left() + case between: + iterator.node = iterator.node.Next() + } + + if iterator.node == nil { + iterator.position = end + return false + } + return true +} + +// Prev moves the iterator to the next element and returns true if there was a previous element in the container. +// If Prev() returns true, then next element's key and value can be retrieved by Key() and Value(). +// If Prev() was called for the first time, then it will point the iterator to the first element if it exists. +// Modifies the state of the iterator. +func (iterator *Iterator) Prev() bool { + switch iterator.position { + case end: + iterator.position = between + iterator.node = iterator.tree.Right() + case between: + iterator.node = iterator.node.Prev() + } + + if iterator.node == nil { + iterator.position = begin + return false + } + return true +} + +// Value returns the current element's value. +// Does not modify the state of the iterator. +func (iterator *Iterator) Value() interface{} { + if iterator.node == nil { + return nil + } + return iterator.node.Value +} + +// Key returns the current element's key. +// Does not modify the state of the iterator. +func (iterator *Iterator) Key() interface{} { + if iterator.node == nil { + return nil + } + return iterator.node.Key +} + +// Begin resets the iterator to its initial state (one-before-first) +// Call Next() to fetch the first element if any. +func (iterator *Iterator) Begin() { + iterator.node = nil + iterator.position = begin +} + +// End moves the iterator past the last element (one-past-the-end). +// Call Prev() to fetch the last element if any. +func (iterator *Iterator) End() { + iterator.node = nil + iterator.position = end +} + +// First moves the iterator to the first element and returns true if there was a first element in the container. +// If First() returns true, then first element's key and value can be retrieved by Key() and Value(). +// Modifies the state of the iterator +func (iterator *Iterator) First() bool { + iterator.Begin() + return iterator.Next() +} + +// Last moves the iterator to the last element and returns true if there was a last element in the container. +// If Last() returns true, then last element's key and value can be retrieved by Key() and Value(). +// Modifies the state of the iterator. +func (iterator *Iterator) Last() bool { + iterator.End() + return iterator.Prev() +} diff --git a/priority_queue/priority_queue.go b/priority_queue/priority_queue.go index 5d6e305..af6fba0 100644 --- a/priority_queue/priority_queue.go +++ b/priority_queue/priority_queue.go @@ -8,7 +8,7 @@ import ( // PriorityQueue 优先队列 适合数据量不大, 加索引 type PriorityQueue struct { - avlIndex *avltree.Tree + index *avltree.Tree indexlimit int node *Node @@ -34,7 +34,7 @@ func NewWithInt() *PriorityQueue { } p.indexlimit = 10 - p.avlIndex = avltree.NewWith(p.comparator) + p.index = avltree.NewWith(p.comparator) return p } @@ -50,129 +50,102 @@ func (pq *PriorityQueue) String() string { content = content[:len(content)-1] } } - - idxContent := "" - for idx := pq.index; idx != nil; idx = idx.next { - idxContent += spew.Sprint(idx.node.value) + "(" + spew.Sprint(idx.nlen) + ")-" - } - - return content + "\n" + idxContent + return content } -func (pq *PriorityQueue) findIndexStart(v interface{}) *Index { - // find the node of index to start - idx := pq.index - for { - if idx.next == nil { - break - } +// func (pq *PriorityQueue) Get(index int) (interface{}, bool) { +// if index < 0 || index >= pq.size { +// return nil, false +// } - if pq.comparator(v, idx.next.node.value) > 0 { - break - } +// idx := pq.index +// movesize := index +// for { +// if movesize-idx.nlen <= 0 { +// break +// } else { +// movesize -= idx.nlen +// idx = idx.next +// } +// } - idx = idx.next - } - return idx -} +// cur := idx.node +// for movesize > 0 { +// movesize-- +// cur = cur.next +// } -func (pq *PriorityQueue) Get(index int) (interface{}, bool) { - if index < 0 || index >= pq.size { - return nil, false - } +// return cur.value, true +// } - idx := pq.index - movesize := index - for { - if movesize-idx.nlen <= 0 { - break - } else { - movesize -= idx.nlen - idx = idx.next - } - } +// func (pq *PriorityQueue) Push(v interface{}) { - cur := idx.node - for movesize > 0 { - movesize-- - cur = cur.next - } +// node := &Node{value: v} +// pq.size++ - return cur.value, true -} +// if pq.node == nil { +// //创建索引 +// pq.index.Put(node, 1) -func (pq *PriorityQueue) Push(v interface{}) { +// pq.node = node +// return +// } +// // find the node of index to start +// fool, ok := pq.index.Ceiling(v) +// cur := idx.node - node := new(Node) - node.value = v - pq.size++ +// if pq.comparator(v, pq.node.value) > 0 { +// pq.node = node +// node.next = cur - if pq.node == nil { - //创建索引 - index := new(Index) - index.nlen = 1 - index.node = node +// pq.index.node = pq.node +// pq.index.nlen++ +// return +// } - pq.index = index - pq.node = node - return - } - // find the node of index to start - idx := pq.findIndexStart(v) - cur := idx.node +// for i := 0; cur.next != nil; i++ { - if pq.comparator(v, pq.node.value) > 0 { - pq.node = node - node.next = cur +// // 分裂和整理索引 +// if i >= pq.indexlimit { - pq.index.node = pq.node - pq.index.nlen++ - return - } +// if idx.next != nil && idx.next.nlen < pq.indexlimit { +// idx.next.nlen += idx.nlen - pq.indexlimit +// idx.nlen = pq.indexlimit +// idx.next.node = cur +// idx = idx.next +// } else { +// index := new(Index) +// index.node = cur +// index.nlen = idx.nlen - pq.indexlimit +// index.next = idx.next - for i := 0; cur.next != nil; i++ { +// idx.next = index +// idx.nlen = pq.indexlimit +// idx = index +// } - // 分裂和整理索引 - if i >= pq.indexlimit { +// i = 0 +// } - if idx.next != nil && idx.next.nlen < pq.indexlimit { - idx.next.nlen += idx.nlen - pq.indexlimit - idx.nlen = pq.indexlimit - idx.next.node = cur - idx = idx.next - } else { - index := new(Index) - index.node = cur - index.nlen = idx.nlen - pq.indexlimit - index.next = idx.next +// if pq.comparator(v, cur.next.value) > 0 { +// temp := cur.next +// cur.next = node +// node.next = temp +// idx.nlen++ +// return +// } +// cur = cur.next - idx.next = index - idx.nlen = pq.indexlimit - idx = index - } +// } - i = 0 - } +// cur.next = node +// idx.nlen++ - if pq.comparator(v, cur.next.value) > 0 { - temp := cur.next - cur.next = node - node.next = temp - idx.nlen++ - return - } - cur = cur.next +// } - } - - cur.next = node - idx.nlen++ - -} - -func (pq *PriorityQueue) Top() (interface{}, bool) { - return pq.Get(0) -} +// func (pq *PriorityQueue) Top() (interface{}, bool) { +// return pq.Get(0) +// } // func (pq *PriorityQueue) Bottom() (interface{}, bool) { // return pq.Get(pq.right - 1) diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go index 0765dd3..2521427 100644 --- a/priority_queue/priority_queue_test.go +++ b/priority_queue/priority_queue_test.go @@ -3,8 +3,6 @@ package plist import ( "testing" - "github.com/emirpasic/gods/trees/avltree" - "github.com/emirpasic/gods/utils" "github.com/Pallinder/go-randomdata" @@ -12,86 +10,95 @@ import ( "github.com/emirpasic/gods/trees/binaryheap" ) -func TestGetPriorityQueue(t *testing.T) { - p := NewWithInt() +// func TestGetPriorityQueue(t *testing.T) { +// p := NewWithInt() - var l []int - for i := 0; i < 10; i++ { - l = append(l, randomdata.Number(0, 10000)) - } +// var l []int +// for i := 0; i < 10; i++ { +// l = append(l, randomdata.Number(0, 10000)) +// } - for _, v := range l { - p.Push(v) - t.Log(p.String()) - } +// for _, v := range l { +// p.Push(v) +// t.Log(p.String()) +// } - t.Error(l) - t.Error(p.String()) +// t.Error(l) +// t.Error(p.String()) - for _, i := range []int{-1, 0, p.size / 2, p.size - 1, p.size} { - v, ok := p.Get(i) - t.Error(i, v, ok) - } +// for _, i := range []int{-1, 0, p.size / 2, p.size - 1, p.size} { +// v, ok := p.Get(i) +// t.Error(i, v, ok) +// } -} +// } -func TestPustPriorityQueue(t *testing.T) { - p := NewWithInt() +// func TestPustPriorityQueue(t *testing.T) { +// p := NewWithInt() - for i := 0; i < 100; i++ { - p.Push(randomdata.Number(0, 10000)) - t.Log(p.String()) - } +// for i := 0; i < 100; i++ { +// p.Push(randomdata.Number(0, 10000)) +// t.Log(p.String()) +// } - t.Error(p.String()) -} +// t.Error(p.String()) +// } -func BenchmarkPriorityQueuePush(b *testing.B) { - p := NewWithInt() +// func BenchmarkPriorityQueuePush(b *testing.B) { +// p := NewWithInt() - // for i := 0; i < 10000; i++ { - // p.Push(randomdata.Number(0, 100000)) - // // p.Values() - // } +// // for i := 0; i < 10000; i++ { +// // p.Push(randomdata.Number(0, 100000)) +// // // p.Values() +// // } - b.N = 10000 - for i := 0; i < b.N; i++ { - p.Push(randomdata.Number(0, 100000)) - } +// b.N = 10000 +// for i := 0; i < b.N; i++ { +// p.Push(randomdata.Number(0, 100000)) +// } -} +// } -func BenchmarkPriorityQueueGet(b *testing.B) { - p := NewWithInt() +// func BenchmarkPriorityQueueGet(b *testing.B) { +// p := NewWithInt() - for i := 0; i < 10000; i++ { - p.Push(randomdata.Number(0, 100000)) - // p.Values() - } +// for i := 0; i < 10000; i++ { +// p.Push(randomdata.Number(0, 100000)) +// // p.Values() +// } - b.StartTimer() - b.N = 100000 - for i := 0; i < b.N; i++ { - p.Get(randomdata.Number(0, 10000)) - } - b.StopTimer() +// b.StartTimer() +// b.N = 100000 +// for i := 0; i < b.N; i++ { +// p.Get(randomdata.Number(0, 10000)) +// } +// b.StopTimer() -} +// } func TestAVL(t *testing.T) { - avl := avltree.NewWithIntComparator() - for i := 0; i < 10; i++ { - v := randomdata.Number(0, 10) - avl.Put(v, v) + avl := NewWithIntComparator() + for i := 0; i < 100; i++ { + v := randomdata.Number(0, 100) + ok, n := avl.Put(v, v) + t.Error(v, ok, n) } t.Error(avl.Values()) - f, ok := avl.Ceiling(100) + f, ok := avl.Ceiling(1000) t.Error(f, ok) - t.Error(f.Next().Value) + if ok { + t.Error(f.Next().Value) + } + + f, ok = avl.Floor(-1) + t.Error(f, ok) + if ok { + t.Error(f.Next().Value) + } } func BenchmarkAVL(b *testing.B) { - avl := avltree.NewWithIntComparator() + avl := NewWithIntComparator() b.N = 1000000 b.StartTimer() From cc50678b6a12bb0c0a5383cdbc3a4c0e0014a25a Mon Sep 17 00:00:00 2001 From: huangsimin Date: Wed, 13 Feb 2019 19:05:56 +0800 Subject: [PATCH 4/6] =?UTF-8?q?Finish:=20=E4=BF=AE=E6=94=B9Put=E8=BF=94?= =?UTF-8?q?=E5=9B=9EPut=E5=85=83=E7=B4=A0=E8=8A=82=E7=82=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- priority_queue/avltree.go | 57 ++++++++++++++------------- priority_queue/iterator.go | 2 +- priority_queue/priority_queue_test.go | 9 +++-- 3 files changed, 36 insertions(+), 32 deletions(-) diff --git a/priority_queue/avltree.go b/priority_queue/avltree.go index 4d80061..db9a559 100644 --- a/priority_queue/avltree.go +++ b/priority_queue/avltree.go @@ -22,17 +22,17 @@ func assertTreeImplementation() { // Tree holds elements of the AVL tree. type Tree struct { - Root *ANode // Root node + Root *AvlNode // Root node Comparator utils.Comparator // Key comparator size int // Total number of keys in the tree } -// ANode is a single element within the tree -type ANode struct { +// AvlNode is a single element within the tree +type AvlNode struct { Key interface{} Value interface{} - Parent *ANode // Parent node - Children [2]*ANode // Children nodes + Parent *AvlNode // Parent node + Children [2]*AvlNode // Children nodes b int8 } @@ -53,8 +53,9 @@ func NewWithStringComparator() *Tree { // Put inserts node into the tree. // Key should adhere to the comparator's type assertion, otherwise method panics. -func (t *Tree) Put(key interface{}, value interface{}) (bool, *ANode) { - return t.put(key, value, nil, &t.Root) +func (t *Tree) Put(key interface{}, value interface{}) (putNode *AvlNode) { + _, putNode = t.put(key, value, nil, &t.Root) + return } // Get searches the node in the tree by key and returns its value or nil if key is not found in tree. @@ -114,13 +115,13 @@ func (t *Tree) Values() []interface{} { // Left returns the minimum element of the AVL tree // or nil if the tree is empty. -func (t *Tree) Left() *ANode { +func (t *Tree) Left() *AvlNode { return t.bottom(0) } // Right returns the maximum element of the AVL tree // or nil if the tree is empty. -func (t *Tree) Right() *ANode { +func (t *Tree) Right() *AvlNode { return t.bottom(1) } @@ -132,7 +133,7 @@ func (t *Tree) Right() *ANode { // all nodes in the tree is larger than the given node. // // Key should adhere to the comparator's type assertion, otherwise method panics. -func (t *Tree) Floor(key interface{}) (floor *ANode, found bool) { +func (t *Tree) Floor(key interface{}) (floor *AvlNode, found bool) { found = false n := t.Root last := n @@ -164,7 +165,7 @@ func (t *Tree) Floor(key interface{}) (floor *ANode, found bool) { // all nodes in the tree is smaller than the given node. // // Key should adhere to the comparator's type assertion, otherwise method panics. -func (t *Tree) Ceiling(key interface{}) (floor *ANode, found bool) { +func (t *Tree) Ceiling(key interface{}) (floor *AvlNode, found bool) { found = false n := t.Root last := n @@ -202,15 +203,15 @@ func (t *Tree) String() string { return str } -func (n *ANode) String() string { +func (n *AvlNode) String() string { return fmt.Sprintf("%v", n.Key) } -func (t *Tree) put(key interface{}, value interface{}, p *ANode, qp **ANode) (bool, *ANode) { +func (t *Tree) put(key interface{}, value interface{}, p *AvlNode, qp **AvlNode) (bool, *AvlNode) { q := *qp if q == nil { t.size++ - *qp = &ANode{Key: key, Value: value, Parent: p} + *qp = &AvlNode{Key: key, Value: value, Parent: p} return true, *qp } @@ -230,12 +231,12 @@ func (t *Tree) put(key interface{}, value interface{}, p *ANode, qp **ANode) (bo var fix bool fix, node := t.put(key, value, q, &q.Children[a]) if fix { - return putFix(int8(c), qp), *qp + return putFix(int8(c), qp), node } - return false, q + return false, node } -func (t *Tree) remove(key interface{}, qp **ANode) bool { +func (t *Tree) remove(key interface{}, qp **AvlNode) bool { q := *qp if q == nil { return false @@ -271,7 +272,7 @@ func (t *Tree) remove(key interface{}, qp **ANode) bool { return false } -func removeMin(qp **ANode, minKey *interface{}, minVal *interface{}) bool { +func removeMin(qp **AvlNode, minKey *interface{}, minVal *interface{}) bool { q := *qp if q.Children[0] == nil { *minKey = q.Key @@ -289,7 +290,7 @@ func removeMin(qp **ANode, minKey *interface{}, minVal *interface{}) bool { return false } -func putFix(c int8, t **ANode) bool { +func putFix(c int8, t **AvlNode) bool { s := *t if s.b == 0 { s.b = c @@ -310,7 +311,7 @@ func putFix(c int8, t **ANode) bool { return false } -func removeFix(c int8, t **ANode) bool { +func removeFix(c int8, t **AvlNode) bool { s := *t if s.b == 0 { s.b = c @@ -339,14 +340,14 @@ func removeFix(c int8, t **ANode) bool { return true } -func singlerot(c int8, s *ANode) *ANode { +func singlerot(c int8, s *AvlNode) *AvlNode { s.b = 0 s = rotate(c, s) s.b = 0 return s } -func doublerot(c int8, s *ANode) *ANode { +func doublerot(c int8, s *AvlNode) *AvlNode { a := (c + 1) / 2 r := s.Children[a] s.Children[a] = rotate(-c, s.Children[a]) @@ -368,7 +369,7 @@ func doublerot(c int8, s *ANode) *ANode { return p } -func rotate(c int8, s *ANode) *ANode { +func rotate(c int8, s *AvlNode) *AvlNode { a := (c + 1) / 2 r := s.Children[a] s.Children[a] = r.Children[a^1] @@ -381,7 +382,7 @@ func rotate(c int8, s *ANode) *ANode { return r } -func (t *Tree) bottom(d int) *ANode { +func (t *Tree) bottom(d int) *AvlNode { n := t.Root if n == nil { return nil @@ -395,17 +396,17 @@ func (t *Tree) bottom(d int) *ANode { // Prev returns the previous element in an inorder // walk of the AVL tree. -func (n *ANode) Prev() *ANode { +func (n *AvlNode) Prev() *AvlNode { return n.walk1(0) } // Next returns the next element in an inorder // walk of the AVL tree. -func (n *ANode) Next() *ANode { +func (n *AvlNode) Next() *AvlNode { return n.walk1(1) } -func (n *ANode) walk1(a int) *ANode { +func (n *AvlNode) walk1(a int) *AvlNode { if n == nil { return nil } @@ -426,7 +427,7 @@ func (n *ANode) walk1(a int) *ANode { return p } -func output(node *ANode, prefix string, isTail bool, str *string) { +func output(node *AvlNode, prefix string, isTail bool, str *string) { if node.Children[1] != nil { newPrefix := prefix if isTail { diff --git a/priority_queue/iterator.go b/priority_queue/iterator.go index da9d9cb..42570c5 100644 --- a/priority_queue/iterator.go +++ b/priority_queue/iterator.go @@ -13,7 +13,7 @@ func assertIteratorImplementation() { // Iterator holding the iterator's state type Iterator struct { tree *Tree - node *ANode + node *AvlNode position position } diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go index 2521427..2d8ea31 100644 --- a/priority_queue/priority_queue_test.go +++ b/priority_queue/priority_queue_test.go @@ -78,10 +78,13 @@ import ( func TestAVL(t *testing.T) { avl := NewWithIntComparator() - for i := 0; i < 100; i++ { + for i := 0; i < 100000; i++ { v := randomdata.Number(0, 100) - ok, n := avl.Put(v, v) - t.Error(v, ok, n) + n := avl.Put(v, v) + if v != n.Value.(int) { + t.Error(v, n) + } + } t.Error(avl.Values()) f, ok := avl.Ceiling(1000) From 62c2c2cb8f40de005db828193dff53807065e79a Mon Sep 17 00:00:00 2001 From: eson <474420502@qq.com> Date: Thu, 14 Feb 2019 02:42:14 +0800 Subject: [PATCH 5/6] TODO: Remove && Pop --- priority_queue/avltree.go | 68 ++++------ priority_queue/iterator.go | 19 +-- priority_queue/priority_queue.go | 179 +++++++------------------- priority_queue/priority_queue_test.go | 124 +++++++++++------- 4 files changed, 158 insertions(+), 232 deletions(-) diff --git a/priority_queue/avltree.go b/priority_queue/avltree.go index db9a559..8de9a82 100644 --- a/priority_queue/avltree.go +++ b/priority_queue/avltree.go @@ -23,13 +23,12 @@ func assertTreeImplementation() { // Tree holds elements of the AVL tree. type Tree struct { Root *AvlNode // Root node - Comparator utils.Comparator // Key comparator + Comparator utils.Comparator // Value comparator size int // Total number of keys in the tree } // AvlNode is a single element within the tree type AvlNode struct { - Key interface{} Value interface{} Parent *AvlNode // Parent node Children [2]*AvlNode // Children nodes @@ -52,33 +51,33 @@ func NewWithStringComparator() *Tree { } // Put inserts node into the tree. -// Key should adhere to the comparator's type assertion, otherwise method panics. -func (t *Tree) Put(key interface{}, value interface{}) (putNode *AvlNode) { - _, putNode = t.put(key, value, nil, &t.Root) +// Value should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Put(key interface{}) (putNode *AvlNode) { + _, putNode = t.put(key, nil, &t.Root) return } -// Get searches the node in the tree by key and returns its value or nil if key is not found in tree. +// Find searches the node in the tree by key and returns its value or nil if key is not found in tree. // Second return parameter is true if key was found, otherwise false. -// Key should adhere to the comparator's type assertion, otherwise method panics. -func (t *Tree) Get(key interface{}) (value interface{}, found bool) { +// Value should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Find(key interface{}) (node *AvlNode, found bool) { n := t.Root for n != nil { - cmp := t.Comparator(key, n.Key) + cmp := t.Comparator(key, n.Value) switch { case cmp == 0: - return n.Value, true + return n, true case cmp < 0: n = n.Children[0] case cmp > 0: n = n.Children[1] } } - return nil, false + return n, false } // Remove remove the node from the tree by key. -// Key should adhere to the comparator's type assertion, otherwise method panics. +// Value should adhere to the comparator's type assertion, otherwise method panics. func (t *Tree) Remove(key interface{}) { t.remove(key, &t.Root) } @@ -93,16 +92,6 @@ func (t *Tree) Size() int { return t.size } -// Keys returns all keys in-order -func (t *Tree) Keys() []interface{} { - keys := make([]interface{}, t.size) - it := t.Iterator() - for i := 0; it.Next(); i++ { - keys[i] = it.Key() - } - return keys -} - // Values returns all values in-order based on the key. func (t *Tree) Values() []interface{} { values := make([]interface{}, t.size) @@ -132,14 +121,14 @@ func (t *Tree) Right() *AvlNode { // A floor node may not be found, either because the tree is empty, or because // all nodes in the tree is larger than the given node. // -// Key should adhere to the comparator's type assertion, otherwise method panics. -func (t *Tree) Floor(key interface{}) (floor *AvlNode, found bool) { +// Value should adhere to the comparator's type assertion, otherwise method panics. +func (t *Tree) Floor(value interface{}) (floor *AvlNode, found bool) { found = false n := t.Root last := n for n != nil { - c := t.Comparator(key, n.Key) + c := t.Comparator(value, n.Value) switch { case c == 0: return n, true @@ -164,13 +153,13 @@ func (t *Tree) Floor(key interface{}) (floor *AvlNode, found bool) { // A ceiling node may not be found, either because the tree is empty, or because // all nodes in the tree is smaller than the given node. // -// Key should adhere to the comparator's type assertion, otherwise method panics. +// Value should adhere to the comparator's type assertion, otherwise method panics. func (t *Tree) Ceiling(key interface{}) (floor *AvlNode, found bool) { found = false n := t.Root last := n for n != nil { - c := t.Comparator(key, n.Key) + c := t.Comparator(key, n.Value) switch { case c == 0: return n, true @@ -204,21 +193,20 @@ func (t *Tree) String() string { } func (n *AvlNode) String() string { - return fmt.Sprintf("%v", n.Key) + return fmt.Sprintf("%v", n.Value) } -func (t *Tree) put(key interface{}, value interface{}, p *AvlNode, qp **AvlNode) (bool, *AvlNode) { +func (t *Tree) put(key interface{}, p *AvlNode, qp **AvlNode) (bool, *AvlNode) { q := *qp if q == nil { t.size++ - *qp = &AvlNode{Key: key, Value: value, Parent: p} + *qp = &AvlNode{Value: key, Parent: p} return true, *qp } - c := t.Comparator(key, q.Key) + c := t.Comparator(key, q.Value) if c == 0 { - q.Key = key - q.Value = value + q.Value = key return false, q } @@ -229,7 +217,7 @@ func (t *Tree) put(key interface{}, value interface{}, p *AvlNode, qp **AvlNode) } a := (c + 1) / 2 var fix bool - fix, node := t.put(key, value, q, &q.Children[a]) + fix, node := t.put(key, q, &q.Children[a]) if fix { return putFix(int8(c), qp), node } @@ -242,7 +230,7 @@ func (t *Tree) remove(key interface{}, qp **AvlNode) bool { return false } - c := t.Comparator(key, q.Key) + c := t.Comparator(key, q.Value) if c == 0 { t.size-- if q.Children[1] == nil { @@ -252,7 +240,7 @@ func (t *Tree) remove(key interface{}, qp **AvlNode) bool { *qp = q.Children[0] return true } - fix := removeMin(&q.Children[1], &q.Key, &q.Value) + fix := removeMin(&q.Children[1], &q.Value) if fix { return removeFix(-1, qp) } @@ -272,18 +260,18 @@ func (t *Tree) remove(key interface{}, qp **AvlNode) bool { return false } -func removeMin(qp **AvlNode, minKey *interface{}, minVal *interface{}) bool { +func removeMin(qp **AvlNode, minKey *interface{}) bool { q := *qp if q.Children[0] == nil { - *minKey = q.Key - *minVal = q.Value + *minKey = q.Value + if q.Children[1] != nil { q.Children[1].Parent = q.Parent } *qp = q.Children[1] return true } - fix := removeMin(&q.Children[0], minKey, minVal) + fix := removeMin(&q.Children[0], minKey) if fix { return removeFix(1, qp) } diff --git a/priority_queue/iterator.go b/priority_queue/iterator.go index 42570c5..16bbb06 100644 --- a/priority_queue/iterator.go +++ b/priority_queue/iterator.go @@ -4,12 +4,6 @@ package plist -import "github.com/emirpasic/gods/containers" - -func assertIteratorImplementation() { - var _ containers.ReverseIteratorWithKey = (*Iterator)(nil) -} - // Iterator holding the iterator's state type Iterator struct { tree *Tree @@ -24,7 +18,7 @@ const ( ) // Iterator returns a stateful iterator whose elements are key/value pairs. -func (tree *Tree) Iterator() containers.ReverseIteratorWithKey { +func (tree *Tree) Iterator() *Iterator { return &Iterator{tree: tree, node: nil, position: begin} } @@ -68,7 +62,7 @@ func (iterator *Iterator) Prev() bool { return true } -// Value returns the current element's value. +// Value returns the current element's Value. // Does not modify the state of the iterator. func (iterator *Iterator) Value() interface{} { if iterator.node == nil { @@ -77,15 +71,6 @@ func (iterator *Iterator) Value() interface{} { return iterator.node.Value } -// Key returns the current element's key. -// Does not modify the state of the iterator. -func (iterator *Iterator) Key() interface{} { - if iterator.node == nil { - return nil - } - return iterator.node.Key -} - // Begin resets the iterator to its initial state (one-before-first) // Call Next() to fetch the first element if any. func (iterator *Iterator) Begin() { diff --git a/priority_queue/priority_queue.go b/priority_queue/priority_queue.go index af6fba0..84f45af 100644 --- a/priority_queue/priority_queue.go +++ b/priority_queue/priority_queue.go @@ -1,27 +1,18 @@ package plist import ( - "github.com/davecgh/go-spew/spew" - "github.com/emirpasic/gods/trees/avltree" "github.com/emirpasic/gods/utils" ) // PriorityQueue 优先队列 适合数据量不大, 加索引 type PriorityQueue struct { - index *avltree.Tree - indexlimit int + data *Tree - node *Node - size int + Head *AvlNode + Tail *AvlNode comparator utils.Comparator } -type Node struct { - value interface{} - // prev *Node - next *Node -} - // NewWithInt compare use int func NewWithInt() *PriorityQueue { p := new(PriorityQueue) @@ -33,136 +24,66 @@ func NewWithInt() *PriorityQueue { return -1 } - p.indexlimit = 10 - p.index = avltree.NewWith(p.comparator) + p.data = NewWith(p.comparator) return p } func (pq *PriorityQueue) String() string { - content := "" - for cur := pq.node; cur != nil; cur = cur.next { - content += spew.Sprint(cur.value) + "-" - } - - if content != "" { - if content[len(content)-1] == '-' { - content = content[:len(content)-1] - } - } - return content + return pq.data.String() } -// func (pq *PriorityQueue) Get(index int) (interface{}, bool) { -// if index < 0 || index >= pq.size { -// return nil, false -// } +func (pq *PriorityQueue) Top() (interface{}, bool) { + return pq.Head, pq.Head != nil +} -// idx := pq.index -// movesize := index -// for { -// if movesize-idx.nlen <= 0 { -// break -// } else { -// movesize -= idx.nlen -// idx = idx.next -// } -// } +func (pq *PriorityQueue) Bottom() (interface{}, bool) { + return pq.Tail, pq.Tail != nil +} -// cur := idx.node -// for movesize > 0 { -// movesize-- -// cur = cur.next -// } +func (pq *PriorityQueue) Get(index int) (interface{}, bool) { + var cur *AvlNode + if index >= 0 { + cur := pq.Head + for index > 0 && cur != nil { + index-- + cur = cur.Prev() + } + } else { + cur := pq.Tail + for index < -1 && cur != nil { + index++ + cur = cur.Next() + } + } -// return cur.value, true -// } + return cur, cur != nil +} -// func (pq *PriorityQueue) Push(v interface{}) { +func (pq *PriorityQueue) Push(v interface{}) { -// node := &Node{value: v} -// pq.size++ + pnode := pq.data.Put(v) + if pq.Head == nil { + pq.Head = pnode + pq.Tail = pnode + return + } -// if pq.node == nil { -// //创建索引 -// pq.index.Put(node, 1) + if pq.comparator(v, pq.Head.Value) > 0 { + pq.Head = pnode + return + } -// pq.node = node -// return -// } -// // find the node of index to start -// fool, ok := pq.index.Ceiling(v) -// cur := idx.node + if pq.comparator(v, pq.Tail.Value) < 0 { + pq.Tail = pnode + return + } +} -// if pq.comparator(v, pq.node.value) > 0 { -// pq.node = node -// node.next = cur +func (pq *PriorityQueue) Remove(index int) interface{} { + return nil +} -// pq.index.node = pq.node -// pq.index.nlen++ -// return -// } - -// for i := 0; cur.next != nil; i++ { - -// // 分裂和整理索引 -// if i >= pq.indexlimit { - -// if idx.next != nil && idx.next.nlen < pq.indexlimit { -// idx.next.nlen += idx.nlen - pq.indexlimit -// idx.nlen = pq.indexlimit -// idx.next.node = cur -// idx = idx.next -// } else { -// index := new(Index) -// index.node = cur -// index.nlen = idx.nlen - pq.indexlimit -// index.next = idx.next - -// idx.next = index -// idx.nlen = pq.indexlimit -// idx = index -// } - -// i = 0 -// } - -// if pq.comparator(v, cur.next.value) > 0 { -// temp := cur.next -// cur.next = node -// node.next = temp -// idx.nlen++ -// return -// } -// cur = cur.next - -// } - -// cur.next = node -// idx.nlen++ - -// } - -// func (pq *PriorityQueue) Top() (interface{}, bool) { -// return pq.Get(0) -// } - -// func (pq *PriorityQueue) Bottom() (interface{}, bool) { -// return pq.Get(pq.right - 1) -// } - -// func (pq *PriorityQueue) Get(index int) (interface{}, bool) { -// if index < pq.size { -// return pq.Values()[index], true -// } -// return nil, false -// } - -// func (pq *PriorityQueue) Values() []interface{} { -// // values := pq.datas[pq.left:pq.right] -// // if !pq.isSorted { -// // utils.Sort(values, pq.comparator) -// // pq.isSorted = true -// // } -// return pq.datas[pq.left:pq.right] -// } +func (pq *PriorityQueue) Values(index int) []interface{} { + return pq.data.Values() +} diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go index 2d8ea31..d8778ac 100644 --- a/priority_queue/priority_queue_test.go +++ b/priority_queue/priority_queue_test.go @@ -10,28 +10,53 @@ import ( "github.com/emirpasic/gods/trees/binaryheap" ) -// func TestGetPriorityQueue(t *testing.T) { -// p := NewWithInt() +func TestPriorityQueueGet(t *testing.T) { + p := NewWithInt() -// var l []int -// for i := 0; i < 10; i++ { -// l = append(l, randomdata.Number(0, 10000)) -// } + var l []int + for i := 0; i < 10; i++ { + l = append(l, randomdata.Number(0, 1000)) + } -// for _, v := range l { -// p.Push(v) -// t.Log(p.String()) -// } + for _, v := range l { + p.Push(v) + t.Log(p.String()) + } -// t.Error(l) -// t.Error(p.String()) + t.Error(p.data.Values()) -// for _, i := range []int{-1, 0, p.size / 2, p.size - 1, p.size} { -// v, ok := p.Get(i) -// t.Error(i, v, ok) -// } +} -// } +func TestPriorityQueuePush(t *testing.T) { + p := NewWithInt() + + var l []int + for i := 0; i < 20; i++ { + l = append(l, randomdata.Number(0, 5)) + } + + for _, v := range l { + p.Push(v) + t.Log(p.String()) + } + + t.Error(l) + t.Error(p.data.Values(), p.Head, p.Tail) + + cur := p.Head + for cur != nil { + t.Error(cur.Value) + cur = cur.Prev() + } + + t.Error("-----") + + cur = p.Tail + for cur != nil { + t.Error(cur.Value) + cur = cur.Next() + } +} // func TestPustPriorityQueue(t *testing.T) { // p := NewWithInt() @@ -44,43 +69,38 @@ import ( // t.Error(p.String()) // } -// func BenchmarkPriorityQueuePush(b *testing.B) { -// p := NewWithInt() +func BenchmarkPriorityQueuePush(b *testing.B) { + p := NewWithInt() -// // for i := 0; i < 10000; i++ { -// // p.Push(randomdata.Number(0, 100000)) -// // // p.Values() -// // } + b.N = 1000000 + for i := 0; i < b.N; i++ { + p.Push(randomdata.Number(0, 100000)) + } +} -// b.N = 10000 -// for i := 0; i < b.N; i++ { -// p.Push(randomdata.Number(0, 100000)) -// } +func BenchmarkPriorityQueueGet(b *testing.B) { + p := NewWithInt() -// } + for i := 0; i < 500000; i++ { + p.Push(randomdata.Number(0, 100000)) + // p.Values() + } -// func BenchmarkPriorityQueueGet(b *testing.B) { -// p := NewWithInt() + b.ResetTimer() + b.StartTimer() + b.N = 100000 + for i := 0; i < b.N; i++ { + p.Get(randomdata.Number(0, 1000)) + } + b.StopTimer() -// for i := 0; i < 10000; i++ { -// p.Push(randomdata.Number(0, 100000)) -// // p.Values() -// } - -// b.StartTimer() -// b.N = 100000 -// for i := 0; i < b.N; i++ { -// p.Get(randomdata.Number(0, 10000)) -// } -// b.StopTimer() - -// } +} func TestAVL(t *testing.T) { avl := NewWithIntComparator() for i := 0; i < 100000; i++ { v := randomdata.Number(0, 100) - n := avl.Put(v, v) + n := avl.Put(v) if v != n.Value.(int) { t.Error(v, n) } @@ -98,6 +118,18 @@ func TestAVL(t *testing.T) { if ok { t.Error(f.Next().Value) } + + root := avl.Root + for root != nil { + t.Error(root.Value) + root = root.Next() + } + + root = avl.Root + for root != nil { + t.Error(root.Value) + root = root.Prev() + } } func BenchmarkAVL(b *testing.B) { @@ -107,11 +139,11 @@ func BenchmarkAVL(b *testing.B) { b.StartTimer() for i := 0; i < b.N; i++ { v := randomdata.Number(0, 100000000) - avl.Put(v, v) + avl.Put(v) } for i := 0; i < b.N; i++ { - avl.Get(i) + avl.Find(i) } b.StopTimer() From 86a8ee11986ed2002b8beb5420349f350594efd7 Mon Sep 17 00:00:00 2001 From: huangsimin Date: Thu, 14 Feb 2019 18:36:19 +0800 Subject: [PATCH 6/6] TODO: to finish --- priority_queue/avltree.go | 32 +++++++++----- priority_queue/iterator.go | 2 +- priority_queue/priority_queue.go | 63 +++++++++++++++++++++++++-- priority_queue/priority_queue_test.go | 50 ++++++++++++++------- 4 files changed, 116 insertions(+), 31 deletions(-) diff --git a/priority_queue/avltree.go b/priority_queue/avltree.go index 8de9a82..0e16be4 100644 --- a/priority_queue/avltree.go +++ b/priority_queue/avltree.go @@ -11,6 +11,7 @@ package plist import ( "fmt" + "log" "github.com/emirpasic/gods/trees" "github.com/emirpasic/gods/utils" @@ -29,7 +30,7 @@ type Tree struct { // AvlNode is a single element within the tree type AvlNode struct { - Value interface{} + Value []interface{} Parent *AvlNode // Parent node Children [2]*AvlNode // Children nodes b int8 @@ -97,7 +98,11 @@ func (t *Tree) Values() []interface{} { values := make([]interface{}, t.size) it := t.Iterator() for i := 0; it.Next(); i++ { - values[i] = it.Value() + for _, v := range it.Value() { + log.Println(len(values), i) + values[i] = v + i++ + } } return values } @@ -128,7 +133,7 @@ func (t *Tree) Floor(value interface{}) (floor *AvlNode, found bool) { last := n for n != nil { - c := t.Comparator(value, n.Value) + c := t.Comparator(value, n.Value[0]) switch { case c == 0: return n, true @@ -159,7 +164,7 @@ func (t *Tree) Ceiling(key interface{}) (floor *AvlNode, found bool) { n := t.Root last := n for n != nil { - c := t.Comparator(key, n.Value) + c := t.Comparator(key, n.Value[0]) switch { case c == 0: return n, true @@ -200,14 +205,15 @@ func (t *Tree) put(key interface{}, p *AvlNode, qp **AvlNode) (bool, *AvlNode) { q := *qp if q == nil { t.size++ - *qp = &AvlNode{Value: key, Parent: p} + *qp = &AvlNode{Value: []interface{}{key}, Parent: p} return true, *qp } - c := t.Comparator(key, q.Value) + c := t.Comparator(key, q.Value[0]) if c == 0 { - q.Value = key - return false, q + t.size++ + q.Value = append(q.Value, key) + return false, q // TODO: } if c < 0 { @@ -232,7 +238,13 @@ func (t *Tree) remove(key interface{}, qp **AvlNode) bool { c := t.Comparator(key, q.Value) if c == 0 { + t.size-- + if len(q.Value) > 1 { + q.Value = q.Value[1:] + return false + } + if q.Children[1] == nil { if q.Children[0] != nil { q.Children[0].Parent = q.Parent @@ -240,7 +252,7 @@ func (t *Tree) remove(key interface{}, qp **AvlNode) bool { *qp = q.Children[0] return true } - fix := removeMin(&q.Children[1], &q.Value) + fix := removeMin(&q.Children[1], &q.Value[0]) if fix { return removeFix(-1, qp) } @@ -263,7 +275,7 @@ func (t *Tree) remove(key interface{}, qp **AvlNode) bool { func removeMin(qp **AvlNode, minKey *interface{}) bool { q := *qp if q.Children[0] == nil { - *minKey = q.Value + *minKey = q.Value[0] if q.Children[1] != nil { q.Children[1].Parent = q.Parent diff --git a/priority_queue/iterator.go b/priority_queue/iterator.go index 16bbb06..d383a02 100644 --- a/priority_queue/iterator.go +++ b/priority_queue/iterator.go @@ -64,7 +64,7 @@ func (iterator *Iterator) Prev() bool { // Value returns the current element's Value. // Does not modify the state of the iterator. -func (iterator *Iterator) Value() interface{} { +func (iterator *Iterator) Value() []interface{} { if iterator.node == nil { return nil } diff --git a/priority_queue/priority_queue.go b/priority_queue/priority_queue.go index 84f45af..f9868ed 100644 --- a/priority_queue/priority_queue.go +++ b/priority_queue/priority_queue.go @@ -1,6 +1,8 @@ package plist import ( + "log" + "github.com/emirpasic/gods/utils" ) @@ -18,9 +20,15 @@ func NewWithInt() *PriorityQueue { p := new(PriorityQueue) p.comparator = func(a, b interface{}) int { + + if a.(int) == b.(int) { + return 0 + } + if a.(int) > b.(int) { return 1 } + return -1 } @@ -44,13 +52,32 @@ func (pq *PriorityQueue) Bottom() (interface{}, bool) { func (pq *PriorityQueue) Get(index int) (interface{}, bool) { var cur *AvlNode if index >= 0 { - cur := pq.Head + cur = pq.Head for index > 0 && cur != nil { index-- cur = cur.Prev() } } else { - cur := pq.Tail + cur = pq.Tail + for index < -1 && cur != nil { + index++ + cur = cur.Next() + } + } + return cur.Value, cur != nil +} + +// GetNode unsafe 破坏AvlNode属性会破坏整个数据结构 +func (pq *PriorityQueue) GetNode(index int) (*AvlNode, bool) { + var cur *AvlNode + if index >= 0 { + cur = pq.Head + for index > 0 && cur != nil { + index-- + cur = cur.Prev() + } + } else { + cur = pq.Tail for index < -1 && cur != nil { index++ cur = cur.Next() @@ -80,10 +107,38 @@ func (pq *PriorityQueue) Push(v interface{}) { } } -func (pq *PriorityQueue) Remove(index int) interface{} { +func (pq *PriorityQueue) RemoveNode(node *AvlNode) { + if node == pq.Head { + pq.Head = node.Prev() + } + + if node == pq.Tail { + pq.Tail = node.Next() + } + + pq.data.remove(node.Value, &node) +} + +func (pq *PriorityQueue) Remove(index int) *AvlNode { + + node, ok := pq.GetNode(index) + if ok { + if node == pq.Head { + pq.Head = node.Prev() + } + + if node == pq.Tail { + pq.Tail = node.Next() + } + + next := node.Prev() + log.Println(next, next.Next()) + pq.data.remove(node.Value, &next) + return node + } return nil } -func (pq *PriorityQueue) Values(index int) []interface{} { +func (pq *PriorityQueue) Values() []interface{} { return pq.data.Values() } diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go index d8778ac..5fcb7db 100644 --- a/priority_queue/priority_queue_test.go +++ b/priority_queue/priority_queue_test.go @@ -58,16 +58,21 @@ func TestPriorityQueuePush(t *testing.T) { } } -// func TestPustPriorityQueue(t *testing.T) { -// p := NewWithInt() +func TestPriorityQueueRemove(t *testing.T) { + p := NewWithInt() -// for i := 0; i < 100; i++ { -// p.Push(randomdata.Number(0, 10000)) -// t.Log(p.String()) -// } + for i := 0; i < 20; i++ { + p.Push(randomdata.Number(0, 10)) + } + t.Error(p.Values()) + n, ok := p.GetNode(0) + t.Error(n, ok, p.Head, p.Tail) -// t.Error(p.String()) -// } + for i := 0; i < 20; i++ { + t.Error(p.Remove(0), p.data.Size()) + t.Error(p.Values()) + } +} func BenchmarkPriorityQueuePush(b *testing.B) { p := NewWithInt() @@ -78,6 +83,23 @@ func BenchmarkPriorityQueuePush(b *testing.B) { } } +func BenchmarkPriorityQueueRemove(b *testing.B) { + p := NewWithInt() + + for i := 0; i < 1000000; i++ { + p.Push(randomdata.Number(0, 100000)) + } + + b.StartTimer() + b.N = 1000000 + for i := 0; i < b.N-100; i++ { + p.Remove(randomdata.Number(0, 100)) + } + for p.Remove(0) != nil { + + } +} + func BenchmarkPriorityQueueGet(b *testing.B) { p := NewWithInt() @@ -98,14 +120,12 @@ func BenchmarkPriorityQueueGet(b *testing.B) { func TestAVL(t *testing.T) { avl := NewWithIntComparator() - for i := 0; i < 100000; i++ { + for i := 0; i < 100; i++ { v := randomdata.Number(0, 100) - n := avl.Put(v) - if v != n.Value.(int) { - t.Error(v, n) - } - + avl.Put(v) } + + t.Error(avl.size) t.Error(avl.Values()) f, ok := avl.Ceiling(1000) t.Error(f, ok) @@ -121,13 +141,11 @@ func TestAVL(t *testing.T) { root := avl.Root for root != nil { - t.Error(root.Value) root = root.Next() } root = avl.Root for root != nil { - t.Error(root.Value) root = root.Prev() } }