ADD: 双端队列、队列、栈

app.go

@@ -1,6 +1,6 @@
 /*
  * @Author: NorthCity1984
- * @LastEditTime: 2022-04-01 21:47:35
+ * @LastEditTime: 2022-04-02 12:42:40
  * @Description:
  * @Website: https://grimoire.cn
  * Copyright (c) NorthCity1984 All rights reserved.
@@ -8,20 +8,29 @@
 package main
 
 import (
-	"stl-go/queue"
+	"fmt"
+	"stl-go/dequeue"
 )
 
 func main() {
-	// s := stack.Init[int]()
+	q := dequeue.Init[int]()
-	// s.Push(12)
+	q.LPush(12)
-	// s.Push(13)
+	q.LPush(23)
-	// fmt.Println(s.GetTop())
+	q.LPush(34)
-	// fmt.Println(s.Pop())
+	q.Clear()
-	// fmt.Println(s.Pop())
+	q.LPush(34)
-	// fmt.Println(s.Pop())
+	q.RPush(44)
-	q := queue.Init[int]()
+	fmt.Println(q.LPop())
-	q.Push(12)
+	fmt.Println(q.LPop())
-	q.Push(34)
+	fmt.Println(q.LPop())
+	fmt.Println(q.LPop())
+	// q := queue.Init[int]()
+	// q.Push(12)
+	// q.Push(23)
+	// q.Push(44)
+	// // q.IsEmpty()
+	// fmt.Println(q.Pop())
+	// fmt.Println(q.Pop())
 	// fmt.Println(q.Pop())
 	// fmt.Println(q.Pop())
 }

dequeue/dequeue.go

@@ -0,0 +1,102 @@
+/*
+ * @Author: NorthCity1984
+ * @LastEditTime: 2022-04-02 12:39:15
+ * @Description:
+ * @Website: https://grimoire.cn
+ * Copyright (c) NorthCity1984 All rights reserved.
+ */
+package dequeue
+
+type Number interface {
+	int | int64 | float32 | float64
+}
+
+// dequeue: Based on Double Linked List
+type Dequeue[T Number] struct {
+	size      int
+	leftHead  *dequeueNode[T]
+	rightHead *dequeueNode[T]
+}
+
+type dequeueNode[T Number] struct {
+	Val      T
+	LPointer *dequeueNode[T]
+	RPointer *dequeueNode[T]
+}
+
+func Init[T Number]() *Dequeue[T] {
+	return &Dequeue[T]{size: 0, leftHead: new(dequeueNode[T]), rightHead: new(dequeueNode[T])}
+}
+
+func (q *Dequeue[T]) IsEmpty() bool {
+	return q.size == 0
+}
+
+func (q *Dequeue[T]) Size() int {
+	return q.size
+}
+
+func (q *Dequeue[T]) LPush(val T) bool {
+	newNode := &dequeueNode[T]{Val: val, LPointer: new(dequeueNode[T]), RPointer: q.leftHead}
+	if q.IsEmpty() {
+		q.leftHead = newNode
+		q.rightHead = newNode
+	}
+	q.size++
+	q.leftHead.LPointer = newNode
+	q.leftHead = newNode
+	return true
+}
+
+func (q *Dequeue[T]) LPop() (T, bool) {
+	if q.IsEmpty() {
+		return 0, false
+	}
+	val := q.leftHead.Val
+	q.leftHead = q.leftHead.RPointer
+	q.size--
+	return val, true
+}
+
+func (q *Dequeue[T]) RPush(val T) bool {
+	newNode := &dequeueNode[T]{Val: val, LPointer: q.rightHead, RPointer: new(dequeueNode[T])}
+	if q.IsEmpty() {
+		q.leftHead = newNode
+		q.rightHead = newNode
+	}
+	q.size++
+	q.rightHead.RPointer = newNode
+	q.rightHead = newNode
+	return true
+}
+
+func (q *Dequeue[T]) RPop() (T, bool) {
+	if q.IsEmpty() {
+		return 0, false
+	}
+	val := q.rightHead.Val
+	q.rightHead = q.rightHead.LPointer
+	q.size--
+	return val, true
+}
+
+func (q *Dequeue[T]) LNode() (T, bool) {
+	if q.IsEmpty() {
+		return 0, false
+	}
+	return q.leftHead.Val, true
+}
+
+func (q *Dequeue[T]) RNode() (T, bool) {
+	if q.IsEmpty() {
+		return 0, false
+	}
+	return q.rightHead.Val, true
+}
+
+func (q *Dequeue[T]) Clear() bool {
+	for !q.IsEmpty() {
+		q.RPop()
+	}
+	return q.IsEmpty()
+}

queue/queue.go

@@ -1,50 +1,47 @@
 /*
  * @Author: NorthCity1984
- * @LastEditTime: 2022-04-01 21:46:15
+ * @LastEditTime: 2022-04-02 12:40:51
  * @Description:
  * @Website: https://grimoire.cn
  * Copyright (c) NorthCity1984 All rights reserved.
  */
 package queue
 
+import "stl-go/dequeue"
+
 type Number interface {
 	int | int64 | float32 | float64
 }
 
-type Queue[T Number] struct {
+// queue: Based on dequeue
-	size  int
+type queue[T Number] struct {
-	front *QueueNode[T]
+	content *dequeue.Dequeue[T]
-	end   *QueueNode[T]
 }
 
-type QueueNode[T Number] struct {
+func Init[T Number]() *queue[T] {
-	Val  T
+	return &queue[T]{content: dequeue.Init[T]()}
-	Next *QueueNode[T]
 }
 
-func Init[T Number]() Queue[T] {
+func (q *queue[T]) Push(val T) bool {
-	return Queue[T]{size: 0, front: nil, end: nil}
+	return q.content.RPush(val)
 }
 
-func (q *Queue[T]) IsEmpty() bool {
+func (q *queue[T]) Pop() (T, bool) {
-	return q.size == 0
+	return q.content.LPop()
 }
 
-func (q *Queue[T]) Push(val T) bool {
+func (q *queue[T]) IsEmpty() bool {
-	newNode := QueueNode[T]{Val: val, Next: nil}
+	return q.content.IsEmpty()
-	q.size++
-	q.end.Next = &newNode
-	q.end = &newNode
-	return true
 }
 
-func (q *Queue[T]) GetFront() T { return q.front.Val }
+func (q *queue[T]) Size() int {
-
+	return q.Size()
-func (q *Queue[T]) Pop() (T, bool) {
+}
-	if q.IsEmpty() {
+
-		return 0, false
+func (q *queue[T]) Clear() bool {
-	}
+	return q.content.Clear()
-	retVal := q.front.Val
+}
-	q.front = q.front.Next
+
-	return retVal, true
+func (q *queue[T]) Front() (T, bool) {
+	return q.content.LNode()
 }

stack/stack.go

@@ -1,49 +1,46 @@
 /*
  * @Author: NorthCity1984
- * @LastEditTime: 2022-04-01 21:35:59
+ * @LastEditTime: 2022-04-02 12:39:53
  * @Description:
  * @Website: https://grimoire.cn
  * Copyright (c) NorthCity1984 All rights reserved.
  */
 package stack
 
+import "stl-go/dequeue"
+
 type Number interface {
 	int | int64 | float32 | float64
 }
 
-type Stack[T Number] struct {
+type stack[T Number] struct {
-	size T
+	content *dequeue.Dequeue[T]
-	top  *stackItem[T]
 }
 
-type stackItem[T Number] struct {
+func Init[T Number]() *stack[T] {
-	Val  T
+	return &stack[T]{content: dequeue.Init[T]()}
-	Next *stackItem[T]
 }
 
-func Init[T Number]() Stack[T] {
+func (s *stack[T]) IsEmpty() bool {
-	return Stack[T]{size: 0, top: nil}
+	return s.content.IsEmpty()
 }
 
-func (s *Stack[T]) IsEmpty() bool { return s.size == 0 }
+func (s *stack[T]) Size() int {
-
+	return s.content.Size()
-func (s *Stack[T]) Push(val T) bool {
-	newNode := stackItem[T]{Val: val, Next: s.top}
-	s.size++
-	s.top = &newNode
-	return true
 }
 
-func (s *Stack[T]) GetTop() T {
+func (s *stack[T]) Push(val T) bool {
-	return s.top.Val
+	return s.content.LPush(val)
 }
 
-func (s *Stack[T]) Pop() (T, bool) {
+func (s *stack[T]) Pop() (T, bool) {
-	if s.IsEmpty() {
+	return s.content.LPop()
-		return 0, false
+}
-	}
+
-	retVal := s.top.Val
+func (s *stack[T]) Top() (T, bool) {
-	s.size--
+	return s.content.LNode()
-	s.top = s.top.Next
+}
-	return retVal, true
+
+func (s *stack[T]) Clear() bool {
+	return s.content.Clear()
 }