zishuo/lancet
1
0
Fork 0
mirror of https://github.com/duke-git/lancet.git synced 2025-10-07 16:30:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
5caa14c838681722a31cfee4a690894e16f46e15
lancet/docs/datastructure/queue.md
dudaodong f87ab89207 docs: fix misspell in doc queue.md
2022-06-06 10:34:18 +08:00

1388 lines
21 KiB
Markdown
Raw Blame History

# Queue
A queue is a kind of linear table. It only allows delete operations at the front of the table and insert operations at the rear of the table. This package includes ArrayQueue, LinkedQueue, CircularQueue, and PriorityQueue.
<div STYLE="page-break-after: always;"></div>
## Source
- [https://github.com/duke-git/lancet/blob/main/datastructure/queue/arrayqueue.go](https://github.com/duke-git/lancet/blob/main/datastructure/queue/arrayqueue.go)
- [https://github.com/duke-git/lancet/blob/main/datastructure/queue/linkedqueue.go](https://github.com/duke-git/lancet/blob/main/datastructure/queue/linkedqueue.go)
- [https://github.com/duke-git/lancet/blob/main/datastructure/queue/circularqueue.go](https://github.com/duke-git/lancet/blob/main/datastructure/queue/circularqueue.go)
- [https://github.com/duke-git/lancet/blob/main/datastructure/queue/priorityqueue.go](https://github.com/duke-git/lancet/blob/main/datastructure/queue/priorityqueue.go)
<div STYLE="page-break-after: always;"></div>
## Usage
```go
import (
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
```
<div STYLE="page-break-after: always;"></div>
## Index
### 1. ArrayQueue
- [NewArrayQueue](#NewArrayQueue)
- [Data](#ArrayQueue_Data)
- [Enqueue](#ArrayQueue_Enqueue)
- [Dequeue](#ArrayQueue_Dequeue)
- [Front](#ArrayQueue_Front)
- [Back](#ArrayQueue_Back)
- [Size](#ArrayQueue_Size)
- [IsEmpty](#ArrayQueue_IsEmpty)
- [IsFull](#ArrayQueue_IsFull)
- [Clear](#ArrayQueue_Clear)
- [Contain](#ArrayQueue_Contain)
### 2. LinkedQueue
- [NewLinkedQueue](#NewLinkedQueue)
- [Data](#LinkedQueue_Data)
- [Enqueue](#LinkedQueue_Enqueue)
- [Dequeue](#LinkedQueue_Dequeue)
- [Front](#LinkedQueue_Front)
- [Back](#LinkedQueue_Back)
- [Size](#LinkedQueue_Size)
- [IsEmpty](#LinkedQueue_IsEmpty)
- [Clear](#LinkedQueue_Clear)
- [Contain](#LinkedQueue_Contain)
### 3. CircularQueue
- [NewCircularQueue](#NewCircularQueue)
- [Data](#CircularQueue_Data)
- [Enqueue](#CircularQueue_Enqueue)
- [Dequeue](#CircularQueue_Dequeue)
- [Front](#CircularQueue_Front)
- [Back](#CircularQueue_Back)
- [Size](#CircularQueue_Size)
- [IsEmpty](#CircularQueue_IsEmpty)
- [IsFull](#CircularQueue_IsFull)
- [Clear](#CircularQueue_Clear)
- [Contain](#CircularQueue_Contain)
### 4. PriorityQueue
- [NewPriorityQueue](#NewPriorityQueue)
- [Data](#PriorityQueue_Data)
- [Enqueue](#PriorityQueue_Enqueue)
- [Dequeue](#PriorityQueue_Dequeue)
- [IsEmpty](#PriorityQueue_IsEmpty)
- [IsFull](#PriorityQueue_IsFull)
- [Size](#PriorityQueue_Size)
<div STYLE="page-break-after: always;"></div>
## Documentation
### 1. ArrayQueue
Common queue implemented by slice.
### <span id="NewArrayQueue">NewArrayQueue</span>
<p>Return a ArrayQueue pointer with specific capacity </p>
<b>Signature:</b>
```go
func NewArrayQueue[T any](capacity int) *ArrayQueue[T]
type ArrayQueue[T any] struct {
items []T
head int
tail int
capacity int
size int
}
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
fmt.Println(q.Data()) // []
}
```
### <span id="ArrayQueue_Data">Data</span>
<p>Get all queue data</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Data() []T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
fmt.Println(q.Data()) // []
}
```
### <span id="ArrayQueue_Enqueue">Enqueue</span>
<p>Put element into queue, if queue is full, return false</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Enqueue(item T) bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="ArrayQueue_Dequeue">Dequeue</span>
<p>Remove head element of queue and return it</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Dequeue() (T, bool)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Dequeue()) // 1
fmt.Println(q.Data()) // 2,3
}
```
### <span id="ArrayQueue_Front">Front</span>
<p>Just get the head element of queue</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Front() T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Front()) // 1
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="ArrayQueue_Back">Back</span>
<p>Just get the tail element of queue</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Back() T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Back()) // 3
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="ArrayQueue_Size">Size</span>
<p>Get the number of elements in queue</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Size() int
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Size()) // 3
}
```
### <span id="ArrayQueue_IsEmpty">IsEmpty</span>
<p>Check if queue is empty or not</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) IsEmpty() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
fmt.Println(q.IsEmpty()) // true
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.IsEmpty()) // false
}
```
### <span id="ArrayQueue_IsFull">IsFull</span>
<p>Check if queue is full or not</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) IsFull() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](3)
fmt.Println(q.IsFull()) // false
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.IsFull()) // true
}
```
### <span id="ArrayQueue_Clear">Clear</span>
<p>Clean all data in queue</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Clear()
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
q.Clear()
fmt.Println(q.IsEmpty()) // true
}
```
### <span id="ArrayQueue_Contain">Contain</span>
<p>Check if the value is in queue or not</p>
<b>Signature:</b>
```go
func (q *ArrayQueue[T]) Contain(value T) bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewArrayQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Contain(1)) // true
fmt.Println(q.Contain(4)) // false
}
```
### 2. LinkedQueue
Common queue implemented by link.
### <span id="NewLinkedQueue">NewLinkedQueue</span>
<p>Return a LinkedQueue pointer </p>
<b>Signature:</b>
```go
func NewLinkedQueue[T any]() *LinkedQueue[T]
type LinkedQueue[T any] struct {
head *datastructure.QueueNode[T]
tail *datastructure.QueueNode[T]
length int
}
type QueueNode[T any] struct {
Value T
Next *QueueNode[T]
}
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int]()
fmt.Println(q.Data()) // []
}
```
### <span id="LinkedQueue_Data">Data</span>
<p>Get all queue data</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Data() []T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int]()
fmt.Println(q.Data()) // []
}
```
### <span id="LinkedQueue_Enqueue">Enqueue</span>
<p>Put element into queue</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Enqueue(value T)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="LinkedQueue_Dequeue">Dequeue</span>
<p>Remove head element of queue and return it</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Dequeue() (T, error)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Dequeue()) // 1
fmt.Println(q.Data()) // 2,3
}
```
### <span id="LinkedQueue_Front">Front</span>
<p>Just get the head element of queue</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Front() (*T, error)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Front()) // 1
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="LinkedQueue_Back">Back</span>
<p>Just get the tail element of queue</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Back() (*T, error)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Back()) // 3
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="LinkedQueue_Size">Size</span>
<p>Get the number of elements in queue</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Size() int
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Size()) // 3
}
```
### <span id="LinkedQueue_IsEmpty">IsEmpty</span>
<p>Check if queue is empty or not</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) IsEmpty() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
fmt.Println(q.IsEmpty()) // true
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.IsEmpty()) // false
}
```
### <span id="LinkedQueue_Clear">Clear</span>
<p>Clean all data in queue</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Clear()
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
q.Clear()
fmt.Println(q.IsEmpty()) // true
}
```
### <span id="LinkedQueue_Contain">Contain</span>
<p>Check if the value is in queue or not</p>
<b>Signature:</b>
```go
func (q *LinkedQueue[T]) Contain(value T) bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewLinkedQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Contain(1)) // true
fmt.Println(q.Contain(4)) // false
}
```
### 3. CircularQueue
Circular queue implemented by slice.
### <span id="NewCircularQueue">NewCircularQueue</span>
<p>Return a CircularQueue pointer with specific capacity </p>
<b>Signature:</b>
```go
func NewCircularQueue[T any](capacity int) *CircularQueue[T]
type CircularQueue[T any] struct {
data []T
front int
rear int
capacity int
}
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
fmt.Println(q.Data()) // []
}
```
### <span id="CircularQueue_Data">Data</span>
<p>Get all queue data</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Data() []T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
fmt.Println(q.Data()) // []
}
```
### <span id="CircularQueue_Enqueue">Enqueue</span>
<p>Put element into queue, if queue is full, return error</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Enqueue(value T) error
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="CircularQueue_Dequeue">Dequeue</span>
<p>Remove head element of queue and return it</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Dequeue() (*T, bool)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
val := q.Dequeue()
fmt.Println(*val) // 1
fmt.Println(q.Data()) // 2,3
}
```
### <span id="CircularQueue_Front">Front</span>
<p>Just get head element of queue</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Front() T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Front()) // 1
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="CircularQueue_Back">Back</span>
<p>Just get tail element of queue</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Back() T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Back()) // 3
fmt.Println(q.Data()) // 1,2,3
}
```
### <span id="CircularQueue_Size">Size</span>
<p>Get the number of elements in queue</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Size() int
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Size()) // 3
}
```
### <span id="CircularQueue_IsEmpty">IsEmpty</span>
<p>Check if queue is empty or not</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) IsEmpty() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
fmt.Println(q.IsEmpty()) // true
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.IsEmpty()) // false
}
```
### <span id="CircularQueue_IsFull">IsFull</span>
<p>Check if queue is full or not</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) IsFull() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](3)
fmt.Println(q.IsFull()) // false
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.IsFull()) // true
}
```
### <span id="CircularQueue_Clear">Clear</span>
<p>Clean all data in queue</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Clear()
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
q.Clear()
fmt.Println(q.IsEmpty()) // true
}
```
### <span id="CircularQueue_Contain">Contain</span>
<p>Check if the value is in queue or not</p>
<b>Signature:</b>
```go
func (q *CircularQueue[T]) Contain(value T) bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewCircularQueue[int](5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Contain(1)) // true
fmt.Println(q.Contain(4)) // false
}
```
### 4. PriorityQueue
Common queue implemented by slice.
### <span id="NewPriorityQueue">NewPriorityQueue</span>
<p>Return a PriorityQueue pointer with specific capacity, param `comparator` is used to compare values of type T in the queue. </p>
<b>Signature:</b>
```go
func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T]
type PriorityQueue[T any] struct {
items []T
size int
comparator lancetconstraints.Comparator
}
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewPriorityQueue[int](3)
fmt.Println(q.Data()) // []
}
```
### <span id="PriorityQueue_Data">Data</span>
<p>Get all queue data</p>
<b>Signature:</b>
```go
func (q *PriorityQueue[T]) Data() []T
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
func main() {
q := queue.NewPriorityQueue[int](3)
fmt.Println(q.Data()) // []
}
```
### <span id="PriorityQueue_Enqueue">Enqueue</span>
<p>Put element into queue, if queue is full, return false</p>
<b>Signature:</b>
```go
func (q *PriorityQueue[T]) Enqueue(item T) bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
type intComparator struct{}
func (c *intComparator) Compare(v1, v2 any) int {
val1, _ := v1.(int)
val2, _ := v2.(int)
if val1 < val2 {
return -1
} else if val1 > val2 {
return 1
}
return 0
}
func main() {
comparator := &intComparator{}
q := queue.NewPriorityQueue[int](10, comparator)
for i := 1; i < 11; i++ {
q.Enqueue(i)
}
fmt.Println(q.Data()) // 10, 9, 6, 7, 8, 2, 5, 1, 4, 3
}
```
### <span id="PriorityQueue_Dequeue">Dequeue</span>
<p>Remove head element of queue and return it</p>
<b>Signature:</b>
```go
func (q *PriorityQueue[T]) Dequeue() (T, bool)
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
type intComparator struct{}
func (c *intComparator) Compare(v1, v2 any) int {
val1, _ := v1.(int)
val2, _ := v2.(int)
if val1 < val2 {
return -1
} else if val1 > val2 {
return 1
}
return 0
}
func main() {
comparator := &intComparator{}
q := queue.NewPriorityQueue[int](10, comparator)
for i := 1; i < 11; i++ {
q.Enqueue(i)
}
val, ok := pq.Dequeue()
fmt.Println(val) // 10
fmt.Println(q.Data()) // 9, 8, 6, 7, 3, 2, 5, 1, 4
}
```
### <span id="PriorityQueue_IsEmpty">IsEmpty</span>
<p>Check if queue is empty or not</p>
<b>Signature:</b>
```go
func (q *PriorityQueue[T]) IsEmpty() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
type intComparator struct{}
func (c *intComparator) Compare(v1, v2 any) int {
val1, _ := v1.(int)
val2, _ := v2.(int)
if val1 < val2 {
return -1
} else if val1 > val2 {
return 1
}
return 0
}
func main() {
comparator := &intComparator{}
q := queue.NewPriorityQueue[int](10, comparator)
fmt.Println(q.IsEmpty()) // true
for i := 1; i < 11; i++ {
q.Enqueue(i)
}
fmt.Println(q.IsEmpty()) // false
}
```
### <span id="PriorityQueue_IsFull">IsFull</span>
<p>Check if queue is full or not</p>
<b>Signature:</b>
```go
func (q *PriorityQueue[T]) IsFull() bool
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
type intComparator struct{}
func (c *intComparator) Compare(v1, v2 any) int {
val1, _ := v1.(int)
val2, _ := v2.(int)
if val1 < val2 {
return -1
} else if val1 > val2 {
return 1
}
return 0
}
func main() {
comparator := &intComparator{}
q := queue.NewPriorityQueue[int](10, comparator)
fmt.Println(q.IsFull()) // false
for i := 1; i < 11; i++ {
q.Enqueue(i)
}
fmt.Println(q.IsFull()) // true
}
```
### <span id="PriorityQueue_Size">Size</span>
<p>Get nubmers of elements in queue</p>
<b>Signature:</b>
```go
func (q *PriorityQueue[T]) Size() int
```
<b>Example:</b>
```go
package main
import (
"fmt"
queue "github.com/duke-git/lancet/v2/datastructure/queue"
)
type intComparator struct{}
func (c *intComparator) Compare(v1, v2 any) int {
val1, _ := v1.(int)
val2, _ := v2.(int)
if val1 < val2 {
return -1
} else if val1 > val2 {
return 1
}
return 0
}
func main() {
comparator := &intComparator{}
q := queue.NewPriorityQueue[int](10, comparator)
fmt.Println(q.IsFull()) // false
for i := 1; i < 5; i++ {
q.Enqueue(i)
}
fmt.Println(q.Size()) // 4
}
```
Reference in New Issue View Git Blame Copy Permalink