Merge pull request #280 from ecodeclub/dev

准备 Release v0.0.10

Author: flycash

.devcontainer/devcontainer.json

@@ -0,0 +1,12 @@
+{
+    "image": "mcr.microsoft.com/devcontainers/go:1-1.23-bookworm",
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "golang.go",
+                "eamodio.gitlens",
+                "ms-vscode.makefile-tools"
+            ]
+        }
+    }
+}

.github/workflows/go.yml

@@ -35,7 +35,10 @@ jobs:
         run: go build -v ./...
 
       - name: Test
-        run: go test -race -coverprofile=cover.out ./...
+        run: make ut-coverage
 
-      - name: Post Coverage
-        uses: codecov/codecov-action@v2
+      - name: Upload results to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}

Makefile

@@ -1,28 +1,32 @@
-.PHONY:	bench
-bench:
-	@go test -bench=. -benchmem  ./...
-
-.PHONY:	ut
-ut:
-	@go test -tags=goexperiment.arenas -race ./...
-
-.PHONY:	setup
-setup:
-	@sh ./.script/setup.sh
-
-.PHONY:	fmt
-fmt:
-	@sh ./.script/goimports.sh
-
-.PHONY:	lint
-lint:
-	@golangci-lint run -c .golangci.yml
-
-.PHONY: tidy
-tidy:
-	@go mod tidy -v
-
-.PHONY: check
-check:
-	@$(MAKE) fmt
+.PHONY:	bench
+bench:
+	@go test -bench=. -benchmem  ./...
+
+.PHONY:	ut
+ut:
+	@go test -tags=goexperiment.arenas -race ./...
+
+.PHONY:	ut-coverage
+ut-coverage:
+	@go test -tags=goexperiment.arenas -race -coverprofile=cover.out ./...
+
+.PHONY:	setup
+setup:
+	@sh ./.script/setup.sh
+
+.PHONY:	fmt
+fmt:
+	@sh ./.script/goimports.sh
+
+.PHONY:	lint
+lint:
+	@golangci-lint run -c .golangci.yml
+
+.PHONY: tidy
+tidy:
+	@go mod tidy -v
+
+.PHONY: check
+check:
+	@$(MAKE) fmt
 	@$(MAKE) tidy

internal/queue/priority_queue.go

@@ -35,12 +35,12 @@ type PriorityQueue[T any] struct {
 	compare ekit.Comparator[T]
 	// 队列容量
 	capacity int
-	// 队列中的元素，为便于计算父子节点的index，0位置留空，根节点从1开始
+	// 队列中的元素，根节点从0开始
 	data []T
 }
 
 func (p *PriorityQueue[T]) Len() int {
-	return len(p.data) - 1
+	return len(p.data)
 }
 
 // Cap 无界队列返回0，有界队列返回创建队列时设置的值
@@ -53,19 +53,19 @@ func (p *PriorityQueue[T]) IsBoundless() bool {
 }
 
 func (p *PriorityQueue[T]) isFull() bool {
-	return p.capacity > 0 && len(p.data)-1 == p.capacity
+	return p.capacity > 0 && len(p.data) == p.capacity
 }
 
 func (p *PriorityQueue[T]) isEmpty() bool {
-	return len(p.data) < 2
+	return len(p.data) < 1
 }
 
 func (p *PriorityQueue[T]) Peek() (T, error) {
 	if p.isEmpty() {
 		var t T
 		return t, ErrEmptyQueue
 	}
-	return p.data[1], nil
+	return p.data[0], nil
 }
 
 func (p *PriorityQueue[T]) Enqueue(t T) error {
@@ -74,11 +74,12 @@ func (p *PriorityQueue[T]) Enqueue(t T) error {
 	}
 
 	p.data = append(p.data, t)
-	node, parent := len(p.data)-1, (len(p.data)-1)/2
-	for parent > 0 && p.compare(p.data[node], p.data[parent]) < 0 {
+	node := len(p.data) - 1
+	parent := (node - 1) / 2
+	for parent >= 0 && p.compare(p.data[node], p.data[parent]) < 0 {
 		p.data[parent], p.data[node] = p.data[node], p.data[parent]
 		node = parent
-		parent = parent / 2
+		parent = (parent - 1) >> 1
 	}
 
 	return nil
@@ -90,11 +91,11 @@ func (p *PriorityQueue[T]) Dequeue() (T, error) {
 		return t, ErrEmptyQueue
 	}
 
-	pop := p.data[1]
-	p.data[1] = p.data[len(p.data)-1]
+	pop := p.data[0]
+	p.data[0] = p.data[len(p.data)-1]
 	p.data = p.data[:len(p.data)-1]
 	p.shrinkIfNecessary()
-	p.heapify(p.data, len(p.data)-1, 1)
+	p.heapify(p.data, len(p.data), 0)
 	return pop, nil
 }
 
@@ -107,10 +108,10 @@ func (p *PriorityQueue[T]) shrinkIfNecessary() {
 func (p *PriorityQueue[T]) heapify(data []T, n, i int) {
 	minPos := i
 	for {
-		if left := i * 2; left <= n && p.compare(data[left], data[minPos]) < 0 {
+		if left := i*2 + 1; left < n && p.compare(data[left], data[minPos]) < 0 {
 			minPos = left
 		}
-		if right := i*2 + 1; right <= n && p.compare(data[right], data[minPos]) < 0 {
+		if right := i*2 + 2; right < n && p.compare(data[right], data[minPos]) < 0 {
 			minPos = right
 		}
 		if minPos == i {
@@ -123,14 +124,14 @@ func (p *PriorityQueue[T]) heapify(data []T, n, i int) {
 
 // NewPriorityQueue 创建优先队列 capacity <= 0 时，为无界队列，否则有有界队列
 func NewPriorityQueue[T any](capacity int, compare ekit.Comparator[T]) *PriorityQueue[T] {
-	sliceCap := capacity + 1
+	sliceCap := capacity
 	if capacity < 1 {
 		capacity = 0
 		sliceCap = 64
 	}
 	return &PriorityQueue[T]{
 		capacity: capacity,
-		data:     make([]T, 1, sliceCap),
+		data:     make([]T, 0, sliceCap),
 		compare:  compare,
 	}
 }

internal/queue/priority_queue_benchmark_test.go

@@ -0,0 +1,73 @@
+// Copyright 2021 ecodeclub
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package queue
+
+import "testing"
+
+func BenchmarkPriorityQueue_NoCapacity_Enqueue(b *testing.B) {
+	n := 300000
+	pq := priorityQueueOf(-1, []int{}, compare())
+	b.ResetTimer()
+	for i := n; i > 0; i-- {
+		if pq.Enqueue(i) != nil {
+			b.Fail()
+		}
+	}
+}
+
+func BenchmarkPriorityQueue_NoCapacity_Dequeue(b *testing.B) {
+	n := 300000
+	pq := priorityQueueOf(-1, []int{}, compare())
+	for i := n; i > 0; i-- {
+		if pq.Enqueue(i) != nil {
+			b.Fail()
+		}
+	}
+	b.ResetTimer()
+	for i := 0; i < n; i++ {
+		_, err := pq.Dequeue()
+		if err != nil {
+			b.Fail()
+		}
+	}
+}
+
+func BenchmarkPriorityQueue_Capacity_Enqueue(b *testing.B) {
+	n := 300000
+	pq := priorityQueueOf(n, []int{}, compare())
+	b.ResetTimer()
+	for i := n; i > 0; i-- {
+		if pq.Enqueue(i) != nil {
+			b.Fail()
+		}
+	}
+}
+
+func BenchmarkPriorityQueue_Capacity_Dequeue(b *testing.B) {
+	n := 300000
+	pq := priorityQueueOf(n, []int{}, compare())
+	for i := n; i > 0; i-- {
+		if pq.Enqueue(i) != nil {
+			b.Fail()
+		}
+	}
+	b.ResetTimer()
+	for i := 0; i < n; i++ {
+		_, err := pq.Dequeue()
+		if err != nil {
+			b.Fail()
+		}
+	}
+}