Merge pull request #892 from 0xff-dev/622

Add solution and test-cases for problem 622

Author: 6boris

leetcode/601-700/0622.Design-Circular-Queue/README.md

@@ -1,28 +1,43 @@
 # [622.Design Circular Queue][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle, and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".
 
-**Example 1:**
+One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.
 
-```
-Input: a = "11", b = "1"
-Output: "100"
-```
+Implement the `MyCircularQueue` class:
 
-## 题意
-> ...
+- `MyCircularQueue(k)` Initializes the object with the size of the queue to be `k`.
+- `int Front()` Gets the front item from the queue. If the queue is empty, return `-1`.
+- `int Rear()` Gets the last item from the queue. If the queue is empty, return `-1`.
+- `boolean enQueue(int value)` Inserts an element into the circular queue. Return `true` if the operation is successful.
+- `boolean deQueue()` Deletes an element from the circular queue. Return `true` if the operation is successful.
+- `boolean isEmpty()` Checks whether the circular queue is empty or not.
+- `boolean isFull()` Checks whether the circular queue is full or not.
 
-## 题解
+You must solve the problem without using the built-in queue data structure in your programming language. 
 
-### 思路1
-> ...
-Design Circular Queue
-```go
-```
+**Example 1:**
 
+```
+Input
+["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]
+[[3], [1], [2], [3], [4], [], [], [], [4], []]
+Output
+[null, true, true, true, false, 3, true, true, true, 4]
+
+Explanation
+MyCircularQueue myCircularQueue = new MyCircularQueue(3);
+myCircularQueue.enQueue(1); // return True
+myCircularQueue.enQueue(2); // return True
+myCircularQueue.enQueue(3); // return True
+myCircularQueue.enQueue(4); // return False
+myCircularQueue.Rear();     // return 3
+myCircularQueue.isFull();   // return True
+myCircularQueue.deQueue();  // return True
+myCircularQueue.enQueue(4); // return True
+myCircularQueue.Rear();     // return 4
+```
 
 ## 结语
 

leetcode/601-700/0622.Design-Circular-Queue/Solution.go

@@ -1,5 +1,131 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+type node622 struct {
+	val       int
+	next, pre *node622
+}
+
+type node622List struct {
+	root  *node622
+	count int
+}
+
+func (n *node622List) len() int {
+	return n.count
+}
+
+func (n *node622List) pushEnd(v int) {
+	node := &node622{val: v}
+	n.count++
+	if n.count == 1 {
+		node.next = node
+		node.pre = node
+		n.root = node
+		return
+	}
+	n.root.pre.next = node
+	node.pre = n.root.pre
+	node.next = n.root
+	n.root.pre = node
+}
+
+func (n *node622List) removeFront() {
+	n.count--
+	if n.count == 0 {
+		n.root = nil
+		return
+	}
+	// a,b,c
+	newRoot := n.root.next
+	newRoot.pre = n.root.pre
+	n.root.pre.next = newRoot
+	n.root = newRoot
+}
+
+func (n *node622List) Front() int {
+	if n.count == 0 {
+		return -1
+	}
+	return n.root.val
+}
+func (n *node622List) Back() int {
+	if n.count == 0 {
+		return -1
+	}
+	return n.root.pre.val
+}
+
+type MyCircularQueue struct {
+	root  *node622List
+	count int
+}
+
+func Constructor(k int) MyCircularQueue {
+	return MyCircularQueue{root: &node622List{}, count: k}
+}
+
+func (this *MyCircularQueue) EnQueue(value int) bool {
+	if this.root.count == this.count {
+		return false
+	}
+	this.root.pushEnd(value)
+	return true
+}
+
+func (this *MyCircularQueue) DeQueue() bool {
+	if this.root.count == 0 {
+		return false
+	}
+	this.root.removeFront()
+	return true
+}
+
+func (this *MyCircularQueue) Front() int {
+	return this.root.Front()
+}
+
+func (this *MyCircularQueue) Rear() int {
+	return this.root.Back()
+}
+
+func (this *MyCircularQueue) IsEmpty() bool {
+	return this.root.len() == 0
+}
+
+func (this *MyCircularQueue) IsFull() bool {
+	return this.root.len() == this.count
+}
+
+type opt struct {
+	name string
+	val  int
+}
+
+func Solution(n int, opts []opt) []any {
+	c := Constructor(n)
+	ans := make([]any, len(opts))
+	for i, op := range opts {
+		if op.name == "en" {
+			ans[i] = c.EnQueue(op.val)
+			continue
+		}
+		if op.name == "de" {
+			ans[i] = c.DeQueue()
+			continue
+		}
+		if op.name == "fr" {
+			ans[i] = c.Front()
+			continue
+		}
+		if op.name == "re" {
+			ans[i] = c.Rear()
+			continue
+		}
+		if op.name == "em" {
+			ans[i] = c.IsEmpty()
+			continue
+		}
+		ans[i] = c.IsFull()
+	}
+	return ans
 }

leetcode/601-700/0622.Design-Circular-Queue/Solution_test.go

@@ -10,18 +10,22 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs int
+		opts   []opt
+		expect []any
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", 3, []opt{
+			{"en", 1}, {"en", 2}, {"en", 3},
+			{"en", 4}, {"re", 0}, {"", 0},
+			{"de", 0}, {"en", 4}, {"re", 0},
+		},
+			[]any{true, true, true, false, 3, true, true, true, 4}},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.inputs, c.opts)
 			if !reflect.DeepEqual(got, c.expect) {
 				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
 					c.expect, got, c.inputs)
@@ -30,10 +34,10 @@ func TestSolution(t *testing.T) {
 	}
 }
 
-//	压力测试
+// 压力测试
 func BenchmarkSolution(b *testing.B) {
 }
 
-//	使用案列
+// 使用案列
 func ExampleSolution() {
 }