feat: Add deque structure (#659)

* Added Doubly Ended Queue data structure and a few tests to check

* Added the doubly ended queue data structure along with a few tests and fixed some linting issues

* Added the necessary changes:
	- Made the member of the DoublyEndedQueue struct private
	- Removed unnecessary indentations from package comment
	- Implemented black box testing
	- Used errors.New() to declare a constant error in case a dequeuing operation is called on an empty deque
	- Exported the methods of DoublyEndedQueue
	- Edited the names of getters to follow go's naming conventions.

* Removed redundant zero valued variables

* Transferred the test file to deque_test package

* Removed redundant error variable in deque_test file

* refactored the comments to satisfy godoc standard

* corrected misspelled words

* Update structure/deque/deque.go

Refactored comments to be more descriptive

Co-authored-by: Taj <[email protected]>

* Update structure/deque/deque_test.go

Removed redundant comments

Co-authored-by: Taj <[email protected]>

* removed redundant comments

* Update structure/deque/deque.go

Co-authored-by: Taj <[email protected]>

* Renamed a few method names

* Update structure/deque/deque.go

Co-authored-by: Taj <[email protected]>

* Renamed a few variables

* Removed redundant comment

---------

Co-authored-by: Rak Laptudirm <[email protected]>
Co-authored-by: Taj <[email protected]>

Author: 3 people

structure/deque/deque.go

@@ -0,0 +1,84 @@
+// description: Double Ended Queue is a generalized version of Queue data structure that allows insert and delete at both ends.
+// References:
+//	Wikipedia : https://en.wikipedia.org/wiki/Double-ended_queue
+//	Github: https://www.geeksforgeeks.org/deque-set-1-introduction-applications/
+// author [Sayan](https://github.com/bose-sayan)
+
+// Package deque implements a Double Ended Queue data structure.
+package deque
+
+import (
+	"errors"
+)
+
+// ErrEmptyDequeue is a custom error for handling cases when some dequeuing operation is performed on an empty deque.
+var ErrEmptyDequeue = errors.New("DoublyEnded queue is empty, so can't perform this operation")
+
+type DoublyEndedQueue[T any] struct {
+	deque []T
+}
+
+// New returns a new DoublyEndedQueue.
+func New[T any]() *DoublyEndedQueue[T] {
+	return &DoublyEndedQueue[T]{deque: make([]T, 0)}
+}
+
+// EnqueueFront adds an item at the front of Deque.
+func (dq *DoublyEndedQueue[T]) EnqueueFront(item T) {
+	dq.deque = append([]T{item}, dq.deque...)
+}
+
+// EnqueueRear adds an item at the rear of Deque.
+func (dq *DoublyEndedQueue[T]) EnqueueRear(item T) {
+	dq.deque = append(dq.deque, item)
+}
+
+// DequeueFront deletes an item from front of Deque and returns it.
+func (dq *DoublyEndedQueue[T]) DequeueFront() (T, error) {
+	if len(dq.deque) == 0 {
+		var zeroVal T
+		return zeroVal, ErrEmptyDequeue
+	}
+	frontElement := dq.deque[0]
+	dq.deque = dq.deque[1:]
+	return frontElement, nil
+}
+
+// DequeueRear deletes an item from rear of Deque and returns it.
+func (dq *DoublyEndedQueue[T]) DequeueRear() (T, error) {
+	if len(dq.deque) == 0 {
+		var zeroVal T
+		return zeroVal, ErrEmptyDequeue
+	}
+	rearElement := dq.deque[len(dq.deque)-1]
+	dq.deque = dq.deque[:len(dq.deque)-1]
+	return rearElement, nil
+}
+
+// Front gets the front item from queue.
+func (dq *DoublyEndedQueue[T]) Front() (T, error) {
+	if (len(dq.deque)) == 0 {
+		var zeroVal T
+		return zeroVal, ErrEmptyDequeue
+	}
+	return dq.deque[0], nil
+}
+
+// Rear gets the last item from queue.
+func (dq *DoublyEndedQueue[T]) Rear() (T, error) {
+	if (len(dq.deque)) == 0 {
+		var zeroVal T
+		return zeroVal, ErrEmptyDequeue
+	}
+	return dq.deque[len(dq.deque)-1], nil
+}
+
+// IsEmpty checks whether Deque is empty or not.
+func (dq *DoublyEndedQueue[T]) IsEmpty() bool {
+	return len(dq.deque) == 0
+}
+
+// Length gets the length of Deque.
+func (dq *DoublyEndedQueue[T]) Length() int {
+	return len(dq.deque)
+}