diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index c6d76e6..b035b7b 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,3 +1,4 @@
 # Add yourself in this file if you are a contributor for Hacktoberfest 2018
 
 - Radu Stochitoiu
+- Antonio Macovei
\ No newline at end of file
diff --git a/CPP/data-structures/Deque.h b/CPP/data-structures/Deque.h
new file mode 100644
index 0000000..350e86a
--- /dev/null
+++ b/CPP/data-structures/Deque.h
@@ -0,0 +1,51 @@
+/*
+	Deque.h
+	Copyright Antonio Macovei
+*/
+
+#ifndef DEQUE_H_
+#define DEQUE_H_
+
+#include "DoublyLinkedList.h"
+
+template<typename T>
+class Deque {
+	private:
+		DoublyLinkedList<T> deque;
+
+	public:
+		void push_front(T data) {
+			deque.add_first(data);
+		}
+
+		void push_back(T data) {
+			deque.add_last(data);
+		}
+
+		void pop_front() {
+			deque.remove_first();
+		}
+
+		void pop_back() {
+			deque.remove_last();
+		}
+
+		T front() {
+			if (!deque.is_empty())
+				return deque.get_head()->data;
+		}
+
+		T back() {
+			if (!deque.is_empty())
+				return deque.get_tail()->data;
+		}
+
+		int size() {
+			return deque.size();
+		}
+
+		bool empty() {
+			return deque.is_empty();
+		}
+};
+#endif  // DEQUE_H_
\ No newline at end of file
diff --git a/CPP/data-structures/DoublyLinkedList.h b/CPP/data-structures/DoublyLinkedList.h
new file mode 100644
index 0000000..94cef57
--- /dev/null
+++ b/CPP/data-structures/DoublyLinkedList.h
@@ -0,0 +1,169 @@
+/*
+	DoublyLinkedList.h
+	Copyright Antonio Macovei
+*/
+
+#ifndef DOUBLYLINKEDLIST_H_
+#define DOUBLYLINKEDLIST_H_
+
+template <typename T>
+struct Node {
+	T data;
+	Node<T> *next;
+	Node<T> *prev;
+
+	explicit Node(T data) {
+		this->data = data;
+		this->next = nullptr;
+		this->prev = nullptr;
+	}
+};
+
+template <typename T>
+class DoublyLinkedList {
+	private:
+		Node<T> *head;
+		Node<T> *tail;
+		int numElements;
+
+		// Returns the pos'th node in the list.
+		Node<T> *goToPos(int pos) {
+		    int count = 0;
+		    Node<T> *it = head;
+
+		    while (count != pos) {
+		        it = it->next;
+		        count++;
+		    }
+		    return it;
+		}
+
+	public:
+		// Constructor
+		DoublyLinkedList() {
+			head = nullptr;
+			tail = nullptr;
+			numElements = 0;
+		}
+
+		// Destructor
+		~DoublyLinkedList() {
+			while (head != nullptr) {
+				Node<T> *temp = head;
+				head = head->next;
+				delete temp;
+			}
+		}
+
+		/**
+		 * Adds a new node at the beginning of the list.
+		 *
+		 * @param data Data to be added at the end of the list.
+		 */
+		void add_first(T data) {
+			if (head == nullptr) {
+				head = new Node<T>(data);
+				head->next = nullptr;
+				head->prev = nullptr;
+				tail = head;
+			} else {
+				Node<T> *new_node;
+				new_node = new Node<T>(data);
+				new_node->next = head;
+				new_node->prev = nullptr;
+				head->prev = new_node;
+				head = new_node;
+			}
+			numElements++;
+		}
+
+		/**
+		 * Adds a new node at the end of the list.
+		 *
+		 * @param data Data to be added at the end of the list.
+		 */
+		void add_last(T data) {
+			if (head == nullptr) {
+				head = new Node<T>(data);
+				head->next = nullptr;
+				head->prev = nullptr;
+				tail = head;
+			} else {
+				Node<T> *new_node;
+				new_node = new Node<T>(data);
+				new_node->next = nullptr;
+				new_node->prev = tail;
+				tail->next = new_node;
+				tail = new_node;
+			}
+			numElements++;
+		}
+
+		/**
+		* Removes the last node of the list.
+		*/
+		void remove_last() {
+			if (numElements == 0) return;
+			if (numElements == 1) {
+				delete tail;
+				tail = nullptr;
+				head = nullptr;
+				numElements = 0;
+			} else {
+				Node<T> *new_tail = tail->prev;
+				tail->prev->next = nullptr;
+				delete tail;
+				tail = new_tail;
+				numElements--;
+			}
+		}
+
+		/**
+		 * Removes the first node of the list.
+		 */
+		void remove_first() {
+			if (numElements == 0) return;
+			if (numElements == 1) {
+				delete head;
+				tail = nullptr;
+				head = nullptr;
+				numElements = 0;
+			} else {
+				Node<T> *new_head = head->next;
+				head->next->prev = nullptr;
+				delete head;
+				head = new_head;
+				numElements--;
+			}
+		}
+
+		/**
+		 * Check if the list contains any elements.
+		 *
+		 * @return True if the list contains no elements, False otherwise.
+		 */
+		bool is_empty() {
+			if (numElements == 0)
+				return true;
+			return false;
+		}
+
+		/**
+		 * Get the number of nodes in the list.
+		 *
+		 * @return The number of nodes stored in the list.
+		 */
+		int size() {
+			return numElements;
+		}
+
+		// Getters & Setters
+		Node<T> *get_head() {
+			return head;
+		}
+
+		Node<T> *get_tail() {
+			return tail;
+		}
+};
+#endif  // DOUBLYLINKEDLIST_H_
\ No newline at end of file
diff --git a/CPP/data-structures/Hashtable.h b/CPP/data-structures/Hashtable.h
new file mode 100644
index 0000000..578e3eb
--- /dev/null
+++ b/CPP/data-structures/Hashtable.h
@@ -0,0 +1,70 @@
+#ifndef HASHTABLE_H_
+#define HASHTABLE_H_
+#include <list>
+
+#define TRESHOLD 0.75
+
+template <typename Tkey, typename Tvalue> struct elem_info {
+	Tkey key;
+	Tvalue value;
+};
+
+template <typename Tkey, typename Tvalue> class Hashtable {
+private:
+	std::list<struct elem_info<Tkey, Tvalue> > * H;  // pointer to buckets
+	int HMAX;  // number of buckets
+	unsigned int (*hash)(Tkey);  // pointer to hash function
+	unsigned int size;  // number of elements in hashtable
+
+public:
+	Hashtable(int hmax, unsigned int (*h)(Tkey)) {
+		HMAX = hmax;
+		H = new std::list<struct elem_info<Tkey, Tvalue> >[hmax];
+		hash = h;
+	}
+
+	~Hashtable() {
+		delete[] H;
+	}
+
+	// Adds an element to the hashtable
+	void put(Tkey key, Tvalue value) {
+		unsigned int index = hash(key) % HMAX;
+		bool found = false;
+		for(auto it : H[index]) {
+			if(it.key == key) {
+				it.value = value;
+				found = true;
+			}
+		}
+		if(!found) {
+			elem_info<Tkey, Tvalue> new_elem;
+			new_elem.key = key;
+			new_elem.value = value;
+			H[index].push_back(new_elem);
+		}
+	}
+
+	// Gets an element from the hashtable
+	Tvalue get(Tkey key) {
+		unsigned int index = hash(key) % HMAX;
+		for(auto it : H[index]) {
+			if(it.key == key) {
+				return it.value;
+			}
+		}
+		return Tvalue();
+	}
+
+	// Gets the hashtable size.
+	int get_size() {
+		return size;
+	}
+
+	// Gets the hastable capacity.
+	int get_capacity() {
+		return HMAX;
+	}
+};
+
+#endif  // HASHTABLE_H__
\ No newline at end of file
diff --git a/CPP/data-structures/ResizableArray.h b/CPP/data-structures/ResizableArray.h
new file mode 100644
index 0000000..18a0e90
--- /dev/null
+++ b/CPP/data-structures/ResizableArray.h
@@ -0,0 +1,130 @@
+/*
+	ResizableArray.h
+	Copyright Antonio Macovei
+*/
+
+#ifndef RESIZABLEARRAY_H_
+#define RESIZABLEARRAY_H_
+
+template <typename T>
+class ResizableArray {
+	private:
+		int defaultCapacity = 1;
+
+		int numElements;
+		int maxCapacity;
+		T *data;
+
+		void resizeArray() {
+			maxCapacity = maxCapacity + 1;
+			T *temp;
+			temp = new T[maxCapacity];
+			for (int i = 0; i < numElements; i++) {
+				temp[i] = data[i];
+			}
+			delete[] data;
+			data = temp;
+		}
+
+		// Shift elements one position to the right
+		void shift_elements_right(int start) {
+			for (int i = numElements; i > start; i--) {
+				data[i] = data[i - 1];
+			}
+		}
+
+		// Shift elements one position to the left
+		void shift_elements_left(int stop) {
+			for (int i = satop; i < numElements; i++) {
+				data[i] = data[i + 1];
+			}
+		}
+
+	public:
+		// Constructor
+		ResizableArray() {
+		    numElements = 0;
+		    maxCapacity = defaultCapacity;
+
+		    data = new T[maxCapacity];
+		}
+
+		// Destructor
+		~ResizableArray() {
+		    delete[] data;
+		}
+
+		/**
+		 * Adds the specified element at the end of the array.
+		 *
+		 * @param element Element to be added at the end of the array.
+		 */
+		void add_last(T element) {
+		    if (numElements == maxCapacity) {
+				resizeArray();
+			}
+			data[numElements] = element;
+			numElements++;
+		}
+
+		/**
+		 * Adds the specified element at the beginning of the array.
+		 *
+		 * @param element Elment to be added at the beginning of the array.
+		 */
+		void add_first(T element) {
+		    if (numElements == maxCapacity) {
+				resizeArray();
+			}
+			numElements++;
+			shift_elements_right(0);
+			data[0] = element;
+		}
+
+		/**
+		 * Removes and returns the last element of the array.
+		 *
+		 * @return Value of the last element stored in the array.
+		 */
+		void remove_last() {
+			if (numElements == 0) return;
+			numElements--;
+		}
+
+		/**
+		 * Removes and returns the first element of the array.
+		 *
+		 * @return Value of the first element stored in the array.
+		 */
+		void remove_first() {
+			if (numElements == 0) return;
+		    shift_elements_left(0);
+			numElements--;
+		}
+
+		/**
+		 * Checks if the array contains any elements.
+		 *
+		 * @return True if the array contains no elements, False otherwise.
+		 */
+		bool is_empty() {
+		    if (numElements == 0)
+				return true;
+			return false;
+		}
+
+		/**
+		 * Returns the number of elements in the array.
+		 *
+		 * @return The number of elements stored in the array.
+		 */
+		int size() {
+		    return numElements;
+		}
+
+		// Getters
+		T *get_data() {
+		    return data;
+		}
+};
+#endif  // RESIZABLEARRAY_H_
\ No newline at end of file