Added DoublyLinkedList in C++

CONTRIBUTORS.md

@@ -1,3 +1,4 @@
 # Add yourself in this file if you are a contributor for Hacktoberfest 2018
 
 - Radu Stochitoiu
+- Antonio Macovei

CPP/data-structures/DoublyLinkedList.h

@@ -0,0 +1,141 @@
+#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:
+	DoublyLinkedList() {
+		head = nullptr;
+		tail = nullptr;
+		numElements = 0;
+	}
+
+	~DoublyLinkedList() {
+		while (head != nullptr) {
+			Node<T> *temp = head;
+			head = head->next;
+			delete temp;
+		}
+	}
+
+	// Adds a new node at the beginning 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
+	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
+	bool is_empty() {
+		if (numElements == 0)
+			return true;
+		return false;
+	}
+
+	// Get the number of nodes in the list
+	int size() {
+		return numElements;
+	}
+
+	Node<T> *get_head() {
+		return head;
+	}
+
+	Node<T> *get_tail() {
+		return tail;
+	}
+};
+#endif  // DOUBLYLINKEDLIST_H_

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_