structure_old/priority_queue/priority_queue.go

package plist

import (
	"github.com/davecgh/go-spew/spew"
	"github.com/emirpasic/gods/utils"
)

// PriorityQueue 优先队列 适合数据量不大, 加索引
type PriorityQueue struct {
	index      *Index
	indexlimit int
	node       *Node
	size       int
	comparator utils.Comparator
}

type Index struct {
	node *Node
	next *Index
	nlen int
}

type Node struct {
	value interface{}

	prev *Node
	next *Node
}

// 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
	}
	return p
}

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 + "-"
	}
	if content[len(content)-1] == '-' {
		content = content[:len(content)-1]
	}
	return content
}

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

		return
	}
	// find the node of index to start
	idx := pq.index

	for {

		if idx.next == nil {
			break
		}

		if pq.comparator(v, idx.next.node.value) > 0 {
			break
		}

		idx = idx.next
	}

	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

		// cur.prev = node
		return
	}

	for cur.next != nil {

		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++

			return
		}

		cur = cur.next
	}

	cur.next = node

	// node.prev = cur
	pq.size++

}

// 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]
// }