Merge branch 'queue_index_with_avl' of http://474420502.top/eson/structure into queue_index_with_avl
This commit is contained in:
huangsimin
commit
6aff3d9af4
456
priority_queue/avltree.go
Normal file
456
priority_queue/avltree.go
Normal file
|
|
@ -0,0 +1,456 @@
|
|||
// 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"
|
||||
"log"
|
||||
|
||||
"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 *AvlNode // Root node
|
||||
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 {
|
||||
Value []interface{}
|
||||
Parent *AvlNode // Parent node
|
||||
Children [2]*AvlNode // 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.
|
||||
// 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
|
||||
}
|
||||
|
||||
// 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.
|
||||
// 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.Value)
|
||||
switch {
|
||||
case cmp == 0:
|
||||
return n, true
|
||||
case cmp < 0:
|
||||
n = n.Children[0]
|
||||
case cmp > 0:
|
||||
n = n.Children[1]
|
||||
}
|
||||
}
|
||||
return n, false
|
||||
}
|
||||
|
||||
// Remove remove the node from the tree by key.
|
||||
// Value 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
|
||||
}
|
||||
|
||||
// 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++ {
|
||||
for _, v := range it.Value() {
|
||||
log.Println(len(values), i)
|
||||
values[i] = v
|
||||
i++
|
||||
}
|
||||
}
|
||||
return values
|
||||
}
|
||||
|
||||
// Left returns the minimum element of the AVL tree
|
||||
// or nil if the tree is empty.
|
||||
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() *AvlNode {
|
||||
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.
|
||||
//
|
||||
// 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(value, n.Value[0])
|
||||
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.
|
||||
//
|
||||
// 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.Value[0])
|
||||
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 *AvlNode) String() string {
|
||||
return fmt.Sprintf("%v", n.Value)
|
||||
}
|
||||
|
||||
func (t *Tree) put(key interface{}, p *AvlNode, qp **AvlNode) (bool, *AvlNode) {
|
||||
q := *qp
|
||||
if q == nil {
|
||||
t.size++
|
||||
*qp = &AvlNode{Value: []interface{}{key}, Parent: p}
|
||||
return true, *qp
|
||||
}
|
||||
|
||||
c := t.Comparator(key, q.Value[0])
|
||||
if c == 0 {
|
||||
t.size++
|
||||
q.Value = append(q.Value, key)
|
||||
return false, q // TODO:
|
||||
}
|
||||
|
||||
if c < 0 {
|
||||
c = -1
|
||||
} else {
|
||||
c = 1
|
||||
}
|
||||
a := (c + 1) / 2
|
||||
var fix bool
|
||||
fix, node := t.put(key, q, &q.Children[a])
|
||||
if fix {
|
||||
return putFix(int8(c), qp), node
|
||||
}
|
||||
return false, node
|
||||
}
|
||||
|
||||
func (t *Tree) remove(key interface{}, qp **AvlNode) bool {
|
||||
q := *qp
|
||||
if q == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
*qp = q.Children[0]
|
||||
return true
|
||||
}
|
||||
fix := removeMin(&q.Children[1], &q.Value[0])
|
||||
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 **AvlNode, minKey *interface{}) bool {
|
||||
q := *qp
|
||||
if q.Children[0] == nil {
|
||||
*minKey = q.Value[0]
|
||||
|
||||
if q.Children[1] != nil {
|
||||
q.Children[1].Parent = q.Parent
|
||||
}
|
||||
*qp = q.Children[1]
|
||||
return true
|
||||
}
|
||||
fix := removeMin(&q.Children[0], minKey)
|
||||
if fix {
|
||||
return removeFix(1, qp)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func putFix(c int8, t **AvlNode) 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 **AvlNode) 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 *AvlNode) *AvlNode {
|
||||
s.b = 0
|
||||
s = rotate(c, s)
|
||||
s.b = 0
|
||||
return s
|
||||
}
|
||||
|
||||
func doublerot(c int8, s *AvlNode) *AvlNode {
|
||||
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 *AvlNode) *AvlNode {
|
||||
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) *AvlNode {
|
||||
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 *AvlNode) Prev() *AvlNode {
|
||||
return n.walk1(0)
|
||||
}
|
||||
|
||||
// Next returns the next element in an inorder
|
||||
// walk of the AVL tree.
|
||||
func (n *AvlNode) Next() *AvlNode {
|
||||
return n.walk1(1)
|
||||
}
|
||||
|
||||
func (n *AvlNode) walk1(a int) *AvlNode {
|
||||
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 *AvlNode, 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)
|
||||
}
|
||||
}
|
||||
102
priority_queue/iterator.go
Normal file
102
priority_queue/iterator.go
Normal file
|
|
@ -0,0 +1,102 @@
|
|||
// 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
|
||||
|
||||
// Iterator holding the iterator's state
|
||||
type Iterator struct {
|
||||
tree *Tree
|
||||
node *AvlNode
|
||||
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() *Iterator {
|
||||
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
|
||||
}
|
||||
|
||||
// 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()
|
||||
}
|
||||
|
|
@ -1,12 +1,18 @@
|
|||
package plist
|
||||
|
||||
import (
|
||||
<<<<<<< HEAD
|
||||
"github.com/emirpasic/gods/trees/avltree"
|
||||
=======
|
||||
"log"
|
||||
|
||||
>>>>>>> 86a8ee11986ed2002b8beb5420349f350594efd7
|
||||
"github.com/emirpasic/gods/utils"
|
||||
)
|
||||
|
||||
// PriorityQueue 优先队列 适合数据量不大, 加索引
|
||||
type PriorityQueue struct {
|
||||
<<<<<<< HEAD
|
||||
avl *avltree.Tree
|
||||
size int
|
||||
comparator utils.Comparator
|
||||
|
|
@ -17,10 +23,31 @@ func NewWithIntComparator() *PriorityQueue {
|
|||
pq := new(PriorityQueue)
|
||||
pq.comparator = func(v1, v2 interface{}) int {
|
||||
if v1.(int) > v2.(int) {
|
||||
=======
|
||||
data *Tree
|
||||
|
||||
Head *AvlNode
|
||||
Tail *AvlNode
|
||||
comparator utils.Comparator
|
||||
}
|
||||
|
||||
// NewWithInt compare use int
|
||||
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) {
|
||||
>>>>>>> 86a8ee11986ed2002b8beb5420349f350594efd7
|
||||
return 1
|
||||
} else if v1.(int) < v2.(int) {
|
||||
return -1
|
||||
}
|
||||
<<<<<<< HEAD
|
||||
return 0
|
||||
}
|
||||
pq.avl = avltree.NewWith(pq.comparator)
|
||||
|
|
@ -71,4 +98,119 @@ func (pq *PriorityQueue) Push(value interface{}) {
|
|||
|
||||
return
|
||||
|
||||
=======
|
||||
|
||||
return -1
|
||||
}
|
||||
|
||||
p.data = NewWith(p.comparator)
|
||||
|
||||
return p
|
||||
}
|
||||
|
||||
func (pq *PriorityQueue) String() string {
|
||||
return pq.data.String()
|
||||
}
|
||||
|
||||
func (pq *PriorityQueue) Top() (interface{}, bool) {
|
||||
return pq.Head, pq.Head != nil
|
||||
}
|
||||
|
||||
func (pq *PriorityQueue) Bottom() (interface{}, bool) {
|
||||
return pq.Tail, pq.Tail != nil
|
||||
}
|
||||
|
||||
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, 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()
|
||||
}
|
||||
}
|
||||
|
||||
return cur, cur != nil
|
||||
}
|
||||
|
||||
func (pq *PriorityQueue) Push(v interface{}) {
|
||||
|
||||
pnode := pq.data.Put(v)
|
||||
if pq.Head == nil {
|
||||
pq.Head = pnode
|
||||
pq.Tail = pnode
|
||||
return
|
||||
}
|
||||
|
||||
if pq.comparator(v, pq.Head.Value) > 0 {
|
||||
pq.Head = pnode
|
||||
return
|
||||
}
|
||||
|
||||
if pq.comparator(v, pq.Tail.Value) < 0 {
|
||||
pq.Tail = pnode
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
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() []interface{} {
|
||||
return pq.data.Values()
|
||||
>>>>>>> 86a8ee11986ed2002b8beb5420349f350594efd7
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import (
|
|||
"github.com/emirpasic/gods/trees/binaryheap"
|
||||
)
|
||||
|
||||
<<<<<<< HEAD
|
||||
func TestPList(t *testing.T) {
|
||||
pl := &PriorityList{}
|
||||
for i := 0; i < 10; i++ {
|
||||
|
|
@ -47,8 +48,67 @@ func BenchmarkPQ(b *testing.B) {
|
|||
b.N = 1000000
|
||||
for i := b.N; i > 0; i-- {
|
||||
pq.Push(i)
|
||||
=======
|
||||
func TestPriorityQueueGet(t *testing.T) {
|
||||
p := NewWithInt()
|
||||
|
||||
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())
|
||||
}
|
||||
|
||||
t.Error(p.data.Values())
|
||||
|
||||
}
|
||||
|
||||
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 TestPriorityQueueRemove(t *testing.T) {
|
||||
p := NewWithInt()
|
||||
|
||||
for i := 0; i < 20; i++ {
|
||||
p.Push(randomdata.Number(0, 10))
|
||||
>>>>>>> 86a8ee11986ed2002b8beb5420349f350594efd7
|
||||
}
|
||||
t.Error(p.Values())
|
||||
n, ok := p.GetNode(0)
|
||||
t.Error(n, ok, p.Head, p.Tail)
|
||||
|
||||
<<<<<<< HEAD
|
||||
iter := pq.avl.Iterator()
|
||||
iter.Next()
|
||||
|
||||
|
|
@ -105,9 +165,109 @@ func TestAvl(t *testing.T) {
|
|||
if ok {
|
||||
t.Error("Ceiling", f)
|
||||
}
|
||||
=======
|
||||
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()
|
||||
|
||||
b.N = 1000000
|
||||
for i := 0; i < b.N; i++ {
|
||||
p.Push(randomdata.Number(0, 100000))
|
||||
}
|
||||
}
|
||||
|
||||
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()
|
||||
|
||||
for i := 0; i < 500000; i++ {
|
||||
p.Push(randomdata.Number(0, 100000))
|
||||
// p.Values()
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
b.StartTimer()
|
||||
b.N = 100000
|
||||
for i := 0; i < b.N; i++ {
|
||||
p.Get(randomdata.Number(0, 1000))
|
||||
}
|
||||
b.StopTimer()
|
||||
|
||||
}
|
||||
|
||||
func TestAVL(t *testing.T) {
|
||||
avl := NewWithIntComparator()
|
||||
for i := 0; i < 100; i++ {
|
||||
v := randomdata.Number(0, 100)
|
||||
avl.Put(v)
|
||||
}
|
||||
|
||||
t.Error(avl.size)
|
||||
t.Error(avl.Values())
|
||||
f, ok := avl.Ceiling(1000)
|
||||
t.Error(f, ok)
|
||||
if ok {
|
||||
t.Error(f.Next().Value)
|
||||
}
|
||||
|
||||
f, ok = avl.Floor(-1)
|
||||
t.Error(f, ok)
|
||||
if ok {
|
||||
t.Error(f.Next().Value)
|
||||
}
|
||||
|
||||
root := avl.Root
|
||||
for root != nil {
|
||||
root = root.Next()
|
||||
}
|
||||
|
||||
root = avl.Root
|
||||
for root != nil {
|
||||
root = root.Prev()
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkAVL(b *testing.B) {
|
||||
avl := NewWithIntComparator()
|
||||
b.N = 1000000
|
||||
|
||||
b.StartTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
v := randomdata.Number(0, 100000000)
|
||||
avl.Put(v)
|
||||
}
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
avl.Find(i)
|
||||
}
|
||||
|
||||
b.StopTimer()
|
||||
>>>>>>> 86a8ee11986ed2002b8beb5420349f350594efd7
|
||||
}
|
||||
|
||||
func TestHeap(t *testing.T) {
|
||||
|
||||
heap := binaryheap.NewWithIntComparator()
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user