From a706d488e6faa1ec98dcadd42ecf1dacb3fe7fce Mon Sep 17 00:00:00 2001 From: dudaodong Date: Sun, 5 Jun 2022 17:29:36 +0800 Subject: [PATCH] feat: add Size func for PriorityQueue --- datastructure/queue/priorityqueue.go | 5 + datastructure/queue/priorityqueue_test.go | 4 + docs/datastructure/queue.md | 619 ++++++++++++++++++++++ 3 files changed, 628 insertions(+) diff --git a/datastructure/queue/priorityqueue.go b/datastructure/queue/priorityqueue.go index f33cf5e..9875486 100644 --- a/datastructure/queue/priorityqueue.go +++ b/datastructure/queue/priorityqueue.go @@ -29,6 +29,11 @@ func (q *PriorityQueue[T]) IsEmpty() bool { return q.size == 0 } +// Size get number of items in the queue +func (q *PriorityQueue[T]) Size() int { + return q.size +} + // IsFull checks if the queue capacity is full or not func (q *PriorityQueue[T]) IsFull() bool { return q.size == len(q.items)-1 diff --git a/datastructure/queue/priorityqueue_test.go b/datastructure/queue/priorityqueue_test.go index 2dd54c1..c2c1a97 100644 --- a/datastructure/queue/priorityqueue_test.go +++ b/datastructure/queue/priorityqueue_test.go @@ -52,9 +52,13 @@ func TestPriorityQueue_Dequeue(t *testing.T) { pq.Enqueue(i) } + assert.Equal(10, pq.Size()) + val, ok := pq.Dequeue() assert.Equal(true, ok) assert.Equal(10, val) assert.Equal([]int{9, 8, 6, 7, 3, 2, 5, 1, 4}, pq.Data()) + + assert.Equal(9, pq.Size()) } diff --git a/docs/datastructure/queue.md b/docs/datastructure/queue.md index 8ce4c84..430a77a 100644 --- a/docs/datastructure/queue.md +++ b/docs/datastructure/queue.md @@ -51,6 +51,30 @@ import ( - [Contain](#LinkedQueue_Contain) +### 3. CircularQueue +- [NewCircularQueue](#NewCircularQueue) +- [Data](#CircularQueue_Data) +- [Enqueue](#CircularQueue_Enqueue) +- [Dequeue](#CircularQueue_Dequeue) +- [Front](#CircularQueue_Front) +- [Back](#CircularQueue_Back) +- [Front](#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) + +
## Documentation @@ -717,3 +741,598 @@ func main() { } ``` + + + +### 3. CircularQueue +Circular queue implemented by slice. + +### NewCircularQueue +

Return a CircularQueue pointer with specific capacity

+ +Signature: + +```go +func NewCircularQueue[T any](capacity int) *CircularQueue[T] + +type CircularQueue[T any] struct { + data []T + front int + rear int + capacity int +} +``` +Example: + +```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()) // [] +} +``` + + + +### Data +

Get all queue data

+ +Signature: + +```go +func (q *CircularQueue[T]) Data() []T +``` +Example: + +```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()) // [] +} +``` + + + + +### Enqueue +

Put element into queue, if queue is full, return error

+ +Signature: + +```go +func (q *CircularQueue[T]) Enqueue(value T) error +``` +Example: + +```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 +} +``` + + + + +### Dequeue +

Remove head element of queue and return it

+ +Signature: + +```go +func (q *CircularQueue[T]) Dequeue() (*T, bool) +``` +Example: + +```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 +} +``` + + + + +### Front +

Just get head element of queue

+ +Signature: + +```go +func (q *CircularQueue[T]) Front() T +``` +Example: + +```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 +} +``` + + + + +### Back +

Just get tail element of queue

+ +Signature: + +```go +func (q *CircularQueue[T]) Back() T +``` +Example: + +```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 +} +``` + + + +### Size +

Get the number of elements in queue

+ +Signature: + +```go +func (q *CircularQueue[T]) Size() int +``` +Example: + +```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 +} +``` + + + +### IsEmpty +

Check if queue is empty or not

+ +Signature: + +```go +func (q *CircularQueue[T]) IsEmpty() bool +``` +Example: + +```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 +} +``` + + + + +### IsFull +

Check if queue is full or not

+ +Signature: + +```go +func (q *CircularQueue[T]) IsFull() bool +``` +Example: + +```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 +} +``` + + + +### Clear +

Clean all data in queue

+ +Signature: + +```go +func (q *CircularQueue[T]) Clear() +``` +Example: + +```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 +} +``` + + + +### Contain +

checks if the value is in queue or not

+ +Signature: + +```go +func (q *CircularQueue[T]) Contain(value T) bool +``` +Example: + +```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. + +### NewPriorityQueue +

Return a PriorityQueue pointer with specific capacity, param `comparator` is used to compare values of type T in the queue.

+ +Signature: + +```go +func NewPriorityQueue[T any](capacity int, comparator lancetconstraints.Comparator) *PriorityQueue[T] + +type PriorityQueue[T any] struct { + items []T + size int + comparator lancetconstraints.Comparator +} +``` +Example: + +```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()) // [] +} +``` + + + +### Data +

Get all queue data

+ +Signature: + +```go +func (q *PriorityQueue[T]) Data() []T +``` +Example: + +```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()) // [] +} +``` + + + + +### Enqueue +

Put element into queue, if queue is full, return false

+ +Signature: + +```go +func (q *PriorityQueue[T]) Enqueue(item T) bool +``` +Example: + +```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 +} +``` + + + + +### Dequeue +

Remove head element of queue and return it

+ +Signature: + +```go +func (q *PriorityQueue[T]) Dequeue() (T, bool) +``` +Example: + +```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 +} +``` + + + +### IsEmpty +

Check if queue is empty or not

+ +Signature: + +```go +func (q *PriorityQueue[T]) IsEmpty() bool +``` +Example: + +```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 +} +``` + + + + +### IsFull +

Check if queue is full or not

+ +Signature: + +```go +func (q *PriorityQueue[T]) IsFull() bool +``` +Example: + +```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 +} +``` +