Added queue implementation

Author: akzare

src/main/cpp/algorithms/datastructures/queue/ArrayQueue.h

@@ -0,0 +1,110 @@
+/*
+ * @file   ArrayQueue.h
+ * @author (original JAVA) William Fiset, [email protected]
+ *                         liujingkun, [email protected]
+ *         (conversion to C++) Armin Zare Zadeh, [email protected]
+ * @date   03 July 2020
+ * @version 0.1
+ * @brief   An array implementation of a queue.
+ */
+
+#ifndef D_ARRAY_QUEUE_H
+#define D_ARRAY_QUEUE_H
+
+#include <Queue.h>
+
+#include <deque>
+#include <vector>
+#include <set>   // set and multiset
+#include <map>   // map and multimap
+#include <unordered_set>  // unordered set/multiset
+#include <unordered_map>  // unordered map/multimap
+#include <iterator>
+#include <algorithm>
+#include <numeric>    // some numeric algorithm
+#include <functional>
+#include <stack>
+
+#include <sstream>
+#include <memory>
+#include <iostream>
+#include <stdexcept>
+
+namespace dsa {
+
+
+template <typename T>
+class ArrayQueue : public Queue<T> {
+private:
+  std::vector<T> data_;
+  int front_;
+  int rear_;
+
+public:
+  ArrayQueue(int id, int capacity) : Queue<T>(id) {
+    // ArrayQueue maximum size is data.length - 1.
+	data_= std::vector<T>(capacity + 1, 0);
+    front_ = 0;
+    rear_ = 0;
+  }
+
+
+  ~ArrayQueue() {
+    data_.clear();
+  }
+
+  void clear() override {
+    front_ = 0;
+    rear_ = 0;
+  }
+
+  void offer(T elem) override {
+    if (isFull()) {
+      throw std::runtime_error("Queue Full");
+    }
+    data_[rear_++] = elem;
+    rear_ = adjustIndex(rear_, data_.size());
+  }
+
+
+  T poll() override {
+    if (isEmpty()) {
+      throw std::runtime_error("Queue Empty");
+    }
+
+    front_ = adjustIndex(front_, data_.size());
+    return (T) data_[front_++];
+  }
+
+
+  T peek() override {
+    if (isEmpty()) {
+      throw std::runtime_error("Queue Empty");
+    }
+    front_ = adjustIndex(front_, data_.size());
+    return (T) data_[front_];
+  }
+
+
+  int size() override {
+    return adjustIndex(rear_ + data_.size() - front_, data_.size());
+  }
+
+
+  bool isEmpty() override {
+    return rear_ == front_;
+  }
+
+  bool isFull() {
+    return (front_ + data_.size() - rear_) % data_.size() == 1;
+  }
+
+private:
+  int adjustIndex(int index, int size) {
+    return index >= size ? index - size : index;
+  }
+};
+
+} // namespace dsa
+
+#endif /* D_ARRAY_QUEUE_H */

src/main/cpp/algorithms/datastructures/queue/LinkedQueue.h

@@ -0,0 +1,136 @@
+/*
+ * @file   LinkedQueue.h
+ * @author (original JAVA) William Fiset, [email protected]
+ *         (conversion to C++) Armin Zare Zadeh, [email protected]
+ * @date   03 July 2020
+ * @version 0.1
+ * @brief   A simple queue implementation with a linkedlist.
+ */
+
+
+#ifndef D_LINKLIST_QUEUE_H
+#define D_LINKLIST_QUEUE_H
+
+#include <Queue.h>
+
+#include <deque>
+#include <list>
+#include <set>   // set and multiset
+#include <map>   // map and multimap
+#include <unordered_set>  // unordered set/multiset
+#include <unordered_map>  // unordered map/multimap
+#include <iterator>
+#include <algorithm>
+#include <numeric>    // some numeric algorithm
+#include <functional>
+#include <stack>
+
+#include <sstream>
+#include <memory>
+#include <iostream>
+#include <stdexcept>
+
+namespace dsa {
+
+template <typename T>
+class LinkedQueue : public Queue<T> {
+
+private:
+  std::list<T> list_;
+
+public:
+  // Create an empty stack
+  LinkedQueue(int id) : Queue<T>(id) {}
+
+  LinkedQueue(int id, T firstElem) : Queue<T>(id) {
+    offer(firstElem);
+  }
+
+  ~LinkedQueue() {
+    list_.clear();
+  }
+
+  // Iterator class can be used to sequentially access nodes of queue
+  class Iterator
+  {
+  public:
+
+    Iterator() noexcept : it_ (list_.begin()) {
+    }
+
+    Iterator& operator=(typename std::list<T>::iterator& it)
+    {
+      this->it_ = it;
+      return *this;
+    }
+
+    // Prefix ++ overload
+    Iterator& operator++()
+    {
+      if (it_)
+    	  it_++;
+      return *this;
+    }
+
+    // Postfix ++ overload
+    Iterator operator++(int)
+    {
+      Iterator iterator = *this;
+      ++*this;
+      return iterator;
+    }
+
+    bool operator!=(const Iterator& iterator)
+    {
+      return it_ != iterator.it_;
+    }
+
+    T operator*()
+    {
+      return *it_;
+    }
+
+  private:
+    const typename std::list<T>::iterator it_;
+  };
+
+  void clear() override {
+    list_.clear();
+  }
+
+  // Return the size of the queue
+  int size() override {
+    return list_.size();
+  }
+
+  // Returns whether or not the queue is empty
+  bool isEmpty() override {
+    return size() == 0;
+  }
+
+  // Peek the element at the front of the queue
+  // The method throws an error is the queue is empty
+  T peek() override {
+    if (isEmpty()) throw std::runtime_error("Queue Empty");
+    return list_.front();
+  }
+
+  // Poll an element from the front of the queue
+  // The method throws an error if the queue is empty
+  T poll() override {
+    if (isEmpty()) throw std::runtime_error("Queue Empty");
+    T f = list_.front();
+    list_.erase(list_.begin());
+    return f;
+  }
+
+  // Add an element to the back of the queue
+  void offer(T elem) override {
+    list_.push_back(elem);
+  }
+
+};
+
+} // namespace dsa
+
+#endif /* D_LINKLIST_QUEUE_H */

src/main/cpp/algorithms/datastructures/queue/Queue.h

@@ -0,0 +1,59 @@
+/*
+ * @file   Queue.h
+ * @author (original JAVA) William Fiset, [email protected]
+ *                         liujingkun, [email protected]
+ *         (conversion to C++) Armin Zare Zadeh, [email protected]
+ * @date   03 July 2020
+ * @version 0.1
+ * @brief   An abstract base class for queue.
+ */
+
+#ifndef D_QUEUE_H
+#define D_QUEUE_H
+
+#include <deque>
+#include <list>
+#include <set>   // set and multiset
+#include <map>   // map and multimap
+#include <unordered_set>  // unordered set/multiset
+#include <unordered_map>  // unordered map/multimap
+#include <iterator>
+#include <algorithm>
+#include <numeric>    // some numeric algorithm
+#include <functional>
+#include <stack>
+
+#include <sstream>
+#include <memory>
+#include <iostream>
+#include <stdexcept>
+
+namespace dsa {
+
+template <typename T>
+class Queue
+{
+private:
+  int id_;
+
+public:
+  Queue(int id) : id_(id) {}
+
+  virtual ~Queue() {}
+
+  virtual void clear() = 0;
+
+  virtual void offer(T elem) = 0;
+
+  virtual T poll() = 0;
+
+  virtual T peek() = 0;
+
+  virtual int size() = 0;
+
+  virtual bool isEmpty() = 0;
+};
+
+} // namespace dsa
+
+#endif /* D_QUEUE_H */

src/main/python/algorithms/datastructures/queue/ArrayQueue.py

@@ -0,0 +1,90 @@
+'''
+ * @file   ArrayStack.py
+ * @author (original JAVA) William Fiset, [email protected]
+ *                         liujingkun, [email protected]
+ *         (conversion to Python) Armin Zare Zadeh, [email protected]
+ * @date   22 Jun 2020
+ * @version 0.1
+ * @brief   An array implementation of a queue.
+'''
+
+from Queue import Queue
+
+class ArrayQueue(Queue):
+  ''' 
+  An array implementation of a stack
+  '''
+  def __init__(self, obj, capacity): 
+    self.qSize = 0
+    self.data = [obj for i in range(capacity)]
+    self.front = 0
+    self.rear = 0
+
+
+  def size(self):
+    return self.adjustIndex(self.rear + len(self.data) - self.front, len(self.data))
+
+
+  def offer(self, elem):
+    if self.isFull():
+      raise Exception('Queue is full')
+
+    self.data[self.rear] = elem
+    self.rear += 1
+    self.rear = self.adjustIndex(self.rear, len(self.data))
+
+
+  def poll(self):
+    if self.isEmpty():
+      raise Exception('Queue is empty')
+    self.front = self.adjustIndex(self.front, len(self.data))
+    d = self.data[self.front]
+    self.front += 1
+    return d
+
+
+  def peek(self):
+    if self.isEmpty():
+      raise Exception('Queue is empty')
+    self.front = self.adjustIndex(self.front, len(self.data))
+    return self.data[self.front]
+
+
+  def isEmpty(self):
+    return self.rear == self.front
+
+
+  def isFull(self):
+    return (self.front + len(self.data) - self.rear) % len(self.data) == 1
+
+
+  def adjustIndex(self, index, size):
+    return index - size if index >= size else index
+
+
+if __name__ == '__main__':
+  q = ArrayQueue(0, 6)
+
+  q.offer(1);
+  q.offer(2);
+  q.offer(3);
+  q.offer(4);
+  q.offer(5);
+
+  print(q.poll()) # 1
+  print(q.poll()) # 2
+  print(q.poll()) # 3
+  print(q.poll()) # 4
+
+  print(q.isEmpty()) # false
+
+  q.offer(1)
+  q.offer(2)
+  q.offer(3)
+
+  print(q.poll()) # 5
+  print(q.poll()) # 1
+  print(q.poll()) # 2
+  print(q.poll()) # 3
+
+  print(q.isEmpty()) # true