diff --git a/priority_queue/avltree.go b/priority_queue/avltree.go
new file mode 100644
index 0000000..0e16be4
--- /dev/null
+++ b/priority_queue/avltree.go
@@ -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)
+	}
+}
diff --git a/priority_queue/iterator.go b/priority_queue/iterator.go
new file mode 100644
index 0000000..d383a02
--- /dev/null
+++ b/priority_queue/iterator.go
@@ -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()
+}
diff --git a/priority_queue/priority_queue.go b/priority_queue/priority_queue.go
index 914c07b..91bacc6 100644
--- a/priority_queue/priority_queue.go
+++ b/priority_queue/priority_queue.go
@@ -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
 }
diff --git a/priority_queue/priority_queue_test.go b/priority_queue/priority_queue_test.go
index 228ecc4..4004e1a 100644
--- a/priority_queue/priority_queue_test.go
+++ b/priority_queue/priority_queue_test.go
@@ -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++ {