Skip to content

Commit 0af64fa

Browse files
spring1843spring1843
authored
Fix circular queue (#176)
Fix the description and solution of the circular queue using array problem
1 parent 911db87 commit 0af64fa

3 files changed

+94
-158
lines changed

‎queue/circular_queue_using_array.go

+30-46
Original file line numberDiff line numberDiff line change
@@ -1,70 +1,54 @@
11
package queue
22

3-
import "errors"
3+
import "math"
4+
5+
const emptyValue = math.MinInt64
46

5-
// CircularQueue is a queue that is made using a circular array.
67
type CircularQueue struct {
7-
data []int
8-
size int
9-
front int
10-
rear int
8+
data []int
9+
size int
10+
head int
11+
tail int
1112
}
1213

13-
const emptyValue = 0
14-
15-
// ErrQueueAtMaxCapacity occurs when the queue is at max capacity.
16-
var ErrQueueAtMaxCapacity = errors.New("queue is at max capacity")
17-
18-
// NewCircularQueue returns a fixed size circular queue.
1914
func NewCircularQueue(size int) *CircularQueue {
20-
circular := make([]int, size)
21-
for i := range circular {
22-
circular[i] = emptyValue
15+
data := make([]int, size)
16+
for i := range data {
17+
data[i] = emptyValue
2318
}
24-
2519
return &CircularQueue{
26-
data: circular,
27-
rear: -1,
28-
size: 0,
29-
front: 0,
20+
data: data,
21+
size: size,
22+
head: -1,
23+
tail: 0,
3024
}
3125
}
3226

33-
// enqueue solves the problem in O(1) time and O(1) space.
34-
func (queue *CircularQueue) enqueue(n int) error {
35-
if queue.isFull() {
36-
return ErrQueueAtMaxCapacity
37-
}
27+
func (queue *CircularQueue) enqueue(n int) {
28+
queue.head = queue.nextCircularSlicePosition(queue.head)
3829

39-
queue.rear++
40-
if queue.rear == queue.capacity() {
41-
queue.rear = 0
30+
if queue.data[queue.head] != emptyValue {
31+
queue.tail = queue.nextCircularSlicePosition(queue.tail)
4232
}
4333

44-
queue.data[queue.rear] = n
45-
queue.size++
46-
return nil
34+
queue.data[queue.head] = n
4735
}
4836

49-
// dequeue solves the problem in O(1) time and O(1) space.
5037
func (queue *CircularQueue) dequeue() (int, error) {
51-
if queue.size == 0 {
38+
if queue.data[queue.tail] == emptyValue {
5239
return 0, ErrQueueEmpty
5340
}
54-
tmp := queue.data[queue.front]
55-
queue.data[queue.front] = emptyValue
56-
queue.front++
57-
if queue.front == queue.capacity() {
58-
queue.front = 0
59-
}
60-
queue.size--
61-
return tmp, nil
62-
}
6341

64-
func (queue *CircularQueue) isFull() bool {
65-
return queue.size == queue.capacity()
42+
output := queue.data[queue.tail]
43+
queue.data[queue.tail] = emptyValue
44+
queue.tail = queue.nextCircularSlicePosition(queue.tail)
45+
return output, nil
6646
}
6747

68-
func (queue *CircularQueue) capacity() int {
69-
return len(queue.data)
48+
func (queue *CircularQueue) nextCircularSlicePosition(value int) int {
49+
value++
50+
if value == queue.size {
51+
return 0
52+
}
53+
return value
7054
}

‎queue/circular_queue_using_array_test.go

+63-111
Original file line numberDiff line numberDiff line change
@@ -5,132 +5,84 @@ import "testing"
55
/*
66
TestCircularQueue tests solution(s) with the following signature and problem description:
77
8-
func (queue *UsingCircularArray) enqueue(n int) error
9-
func (queue *UsingCircularArray) dequeue() (int, error)
8+
func (queue *CircularQueue) enqueue(n int) error
9+
func (queue *CircularQueue) dequeue() (int, error)
10+
11+
Given a size, implement a circular queue using a slice.
1012
11-
Given a size, implement a circular queue using an array.
1213
A circular queue also called a ring buffer is different from a normal queue in that
1314
the last element is connected to the first element.
15+
16+
For example given a circular array of size 4 if we enqueue integers {1,2,3,4,5,6} and then dequeue 2 times
17+
we should get 3 and 4.
18+
19+
, - ~ - , , - ~ - , , - ~ - , , - ~ - ,
20+
, ' ... ' , , ' ... ' , , ' ... ' , , ' ... ' ,
21+
, ... , , ... , , ... , , ... ,
22+
, 1 ... , , 1 ... 2 , , 1 ... 2 , , 1 ... 2 ,
23+
, ... , , ... , , ... , , ... ,
24+
, ................... , , ................... , , ................... , , ................... ,
25+
, ................... , , ................... , , ................... , , ................... ,
26+
, ... , , ... , , ... , , ... ,
27+
, ... , , ... , , ... 3 , , 4 ... 3 ,
28+
, ... , ' , ... , ' , ... , ' , ... , '
29+
' - ,..., ' ' - ,..., ' ' - ,..., ' ' - ,..., '
30+
31+
, - ~ - , , - ~ - , , - ~ - , , - ~ - ,
32+
, ' ... ' , , ' ... ' , , ' ... ' , , ' ... ' ,
33+
, ... , , ... , , ... , , ... ,
34+
, 5 ... 2 , , 5 ... 6 , , 5 ... 6 , , 5 ... 6 ,
35+
, ... , , ... , , ... , , ... ,
36+
, ................... , , ................... , , ................... , , ................... ,
37+
, ................... , , ................... , , ................... , , ................... ,
38+
, ... , , ... , , ... , , ... ,
39+
, 4 ... 3 , , 4 ... 3 , , 4 ... , , ... ,
40+
, ... , ' , ... , ' , ... , ' , ... , '
41+
' - ,..., ' ' - ,..., ' ' - ,..., ' ' - ,..., '
42+
43+
As shown in the above example the circular queue does not run out of capacity and still allows FIFO operations.
1444
*/
1545
func TestCircularQueue(t *testing.T) {
16-
// Tests a queue by enqueues given items,
17-
// then dequeues a number of times and finally checks the value from the last dequeue.
18-
// The same process then may be repeated for a second time with different values.
46+
type testRound struct {
47+
enqueueStart int
48+
enqueueEnd int
49+
dequeueStart int
50+
dequeueEnd int
51+
expectedErr error
52+
}
53+
1954
tests := []struct {
20-
size int
21-
firstRound *testCase
22-
secondRound *testCase
55+
size int
56+
testRounds []testRound
2357
}{
24-
{0, &testCase{[]int{1, 2, 3, 4}, -1, -1, true, false}, nil},
25-
{4, &testCase{[]int{1, 2, 3, 4}, 1, 1, false, false}, nil},
26-
{4, &testCase{[]int{1, 2, 3, 4}, 2, 2, false, false}, nil},
27-
{4, &testCase{[]int{1, 2, 3, 4}, 3, 3, false, false}, nil},
28-
{4, &testCase{[]int{1, 2, 2, 3}, 2, 2, false, false}, nil},
29-
{2, &testCase{[]int{1, 2, 2, 3}, 2, 2, true, false}, nil},
30-
{2, &testCase{[]int{1, 2}, 3, -1, false, true}, nil},
31-
{2, &testCase{[]int{1, 2}, 2, 2, false, false}, &testCase{[]int{1, 2}, 1, 1, false, false}},
32-
{2, &testCase{[]int{1, 2}, 1, 1, false, false}, &testCase{[]int{1}, 2, 1, false, false}},
58+
{1, []testRound{{1, 6, 6, 6, nil}}},
59+
{2, []testRound{{1, 6, 5, 5, nil}}},
60+
{4, []testRound{{1, 6, 3, 6, nil}}},
61+
{4, []testRound{{1, 6, 3, 6, nil}, {1, 6, 3, 6, nil}}},
62+
{4, []testRound{{1, 6, 3, 7, ErrQueueEmpty}}},
3363
}
3464

3565
for i, test := range tests {
3666
queue := NewCircularQueue(test.size)
3767

38-
enqueueDequeueAndCheckValue(t, queue, i, test.firstRound)
39-
if test.secondRound != nil {
40-
enqueueDequeueAndCheckValue(t, queue, i, test.secondRound)
41-
}
42-
}
43-
}
44-
45-
type testCase struct {
46-
enqueue []int
47-
dequeueTimes int
48-
expectedLastDequeuedItem int
49-
expectEnqueueErr bool
50-
expectDequeueErr bool
51-
}
52-
53-
const (
54-
operationTypeEnqueue = iota
55-
operationTypeDequeue
56-
)
57-
58-
var queueOperations = []struct {
59-
operationType int
60-
operationValue int
61-
}{
62-
{operationTypeEnqueue, 3},
63-
{operationTypeEnqueue, 2},
64-
{operationTypeEnqueue, 1},
65-
{operationTypeDequeue, 0},
66-
{operationTypeDequeue, 0},
67-
{operationTypeDequeue, 0},
68-
{operationTypeEnqueue, 3},
69-
{operationTypeEnqueue, 2},
70-
{operationTypeEnqueue, 1},
71-
{operationTypeDequeue, 0},
72-
{operationTypeDequeue, 0},
73-
{operationTypeDequeue, 0},
74-
{operationTypeEnqueue, 5},
75-
{operationTypeDequeue, 0},
76-
{operationTypeEnqueue, 1},
77-
{operationTypeDequeue, 0},
78-
{operationTypeEnqueue, 1},
79-
}
80-
81-
func enqueueDequeueAndCheckValue(t *testing.T, queue *CircularQueue, testID int, test *testCase) {
82-
t.Helper()
83-
for _, n := range test.enqueue {
84-
if err := queue.enqueue(n); err != nil {
85-
if test.expectEnqueueErr {
86-
t.Skipf("Skipping test case #%d. Expected error occurred. Error %s", testID, err)
68+
for j, testRound := range test.testRounds {
69+
for i := testRound.enqueueStart; i <= testRound.enqueueEnd; i++ {
70+
queue.enqueue(i)
8771
}
88-
t.Fatalf("Failed test case #%d. Did not expect enqueuing error. Error %s", testID, err)
89-
}
90-
}
9172

92-
var n int
93-
var err error
94-
for j := 1; j <= test.dequeueTimes; j++ {
95-
n, err = queue.dequeue()
96-
if err != nil {
97-
if test.expectDequeueErr {
98-
t.Skipf("Skipping test case #%d. Expected error occurred. Error %s", testID, err)
73+
for want := testRound.dequeueStart; want <= testRound.dequeueEnd; want++ {
74+
got, err := queue.dequeue()
75+
if err != nil {
76+
if err != testRound.expectedErr {
77+
t.Fatalf("Failed test case #%d round #%d. Unexpected error %s", i, j, err)
78+
}
79+
break
80+
}
81+
82+
if got != want {
83+
t.Fatalf("Failed test case #%d round #%d. Want %d, got %d", i, j, want, got)
84+
}
9985
}
100-
t.Fatalf("Failed test case #%d. Did not expect dequeuing error. Error %s", testID, err)
10186
}
10287
}
103-
if n != test.expectedLastDequeuedItem {
104-
t.Fatalf("Failed test case #%d. Want %d got %d", testID, test.expectedLastDequeuedItem, n)
105-
}
106-
}
107-
108-
func TestMultipleOperations(t *testing.T) {
109-
queue := NewCircularQueue(3)
110-
111-
if _, err := queue.dequeue(); err == nil {
112-
t.Fatal("Expected error for dequeue-ing an empty queue")
113-
}
114-
115-
for i, queueOperation := range queueOperations {
116-
switch queueOperation.operationType {
117-
case operationTypeEnqueue:
118-
if err := queue.enqueue(queueOperation.operationValue); err != nil {
119-
t.Fatalf("operation #%d, unexpected error: %s", i, err)
120-
}
121-
case operationTypeDequeue:
122-
if _, err := queue.dequeue(); err != nil {
123-
t.Fatalf("operation #%d, unexpected error: %s", i, err)
124-
}
125-
}
126-
}
127-
128-
n, err := queue.dequeue()
129-
if err != nil {
130-
t.Fatalf("Failed to dequeue. Error %s", err)
131-
}
132-
133-
if n != 1 {
134-
t.Fatalf("Wanted %d, got %d", 1, n)
135-
}
13688
}

‎queue/max_of_sub_arrays.go

+1-1
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ import (
55
"errors"
66
)
77

8-
// ErrQueueEmpty occurs when popping an empty stack.
8+
// ErrQueueEmpty occurs when dequeuing an empty queue.
99
var ErrQueueEmpty = errors.New("empty queue")
1010

1111
// MaxOfKLengthSubArrays solves the problem in O(n) time and O(k) space.

0 commit comments

Comments
 (0)