#pragma once #include // Include Arduino.h for Serial.println #include class DoublyNode { public: char* data; DoublyNode* next; DoublyNode* prev; // Constructor to initialize the DoublyNode with given data and next pointer DoublyNode(const char* data) { this->next = nullptr; this->prev = nullptr; this->data = new char[strlen(data) + 1]; // Allocate memory for data strcpy(this->data, data); } ~DoublyNode() { Serial.print("Deleted: "); Serial.println(this->data); delete[] this->data; this->data = nullptr; delete this->next; this->next = nullptr; delete this->prev; this->prev = nullptr; } }; class DoublyLinkedList { private: DoublyNode* headNode; DoublyNode* tailNode; DoublyNode* currentNode; DoublyNode* previousNode; void insertAtPosition(int position, const char* data); bool linkedListIsEmpty(); void createTheFirstNode(const char* data); void prependNodeToList(const char* data); void appendNodeToList(const char* data); char* getDataAt(int position); public: DoublyLinkedList(); // ~DoublyLinkedList(); void printDoublyLinkedList(); uint8_t getLength(); void insertAtHead(const char* data); void insertInMiddle(int position, const char* data); char* getDataAtPosition(int position); void insertAtTail(const char* data); void showHeadPointer(); char* getHeadPointerData(); void showTailPointer(); char* getTailPointerData(); void deleteNode(int position); // void deleteAllNodes(); }; // Private functions void DoublyLinkedList::insertAtPosition(int position, const char* data){ this->currentNode = this->headNode; uint8_t currentNodePosition = 1; while (currentNode != nullptr && currentNodePosition < position - 1) { currentNode = currentNode->next; currentNodePosition++; } if (currentNode != nullptr) { DoublyNode* newNode = new DoublyNode(data); newNode->next = currentNode->next; currentNode->next->prev = newNode; currentNode->next = newNode; newNode->prev = currentNode; if (currentNode == this->tailNode) { this->tailNode = newNode; } } } bool DoublyLinkedList::linkedListIsEmpty(){ return this->headNode == nullptr; } void DoublyLinkedList::createTheFirstNode(const char* data) { DoublyNode* newNode = new DoublyNode(data); newNode->next = nullptr; this->headNode = newNode; this->tailNode = newNode; } void DoublyLinkedList::prependNodeToList(const char* data) { DoublyNode* newNode = new DoublyNode(data); newNode->next = this->headNode; this->headNode->prev = newNode; this->headNode = newNode; } void DoublyLinkedList::appendNodeToList(const char* data) { DoublyNode* newNode = new DoublyNode(data); newNode->prev = this->tailNode; this->tailNode->next = newNode; this->tailNode = newNode; } // Public functions DoublyLinkedList::DoublyLinkedList() : headNode(nullptr), tailNode(nullptr) {} void DoublyLinkedList::printDoublyLinkedList() { currentNode = this->headNode; while (currentNode != nullptr) { Serial.println(currentNode->data); currentNode = currentNode->next; } } uint8_t DoublyLinkedList::getLength() { currentNode = this->headNode; uint8_t count=0; while (currentNode != nullptr) { count++; currentNode = currentNode->next; } return count; } void DoublyLinkedList::insertAtHead(const char* data) { if(linkedListIsEmpty()) // The linked list is empty createTheFirstNode(data); else prependNodeToList(data); } void DoublyLinkedList::insertAtTail(const char* data) { if(linkedListIsEmpty()) createTheFirstNode(data); else appendNodeToList(data); } void DoublyLinkedList::insertInMiddle(int position, const char* data){ if (position <= 1) insertAtHead(data); else if((position - 1) < getLength()) insertAtPosition(position,data); else insertAtTail(data); } char* getDataAt(int position) { this->currentNode = this->headNode; uint8_t currentNodePosition = 1; while (currentNode != nullptr && currentNodePosition < position - 1) { currentNode = currentNode->next; currentNodePosition++; } if (currentNode != nullptr) return currentNode->data; } char* DoublyLinkedList::getDataAtPosition(int position){ if (position <= 1) return getHeadPointerData(); else if((position - 1) < getLength()) getDataAt(position); else return getTailPointerData(); } void DoublyLinkedList::showHeadPointer() { Serial.print("Head Pointer pointing to:"); Serial.println(this->headNode->data); } char* DoublyLinkedList::getHeadPointerData() { return headNode->data; } void DoublyLinkedList::showTailPointer() { Serial.print("Tail Pointer pointing to:"); Serial.println(this->tailNode->data); } char* DoublyLinkedList::getTailPointerData() { return tailNode->data; } void DoublyLinkedList::deleteNode(int position) { if (linkedListIsEmpty()) // If the list is empty, nothing to delete return; if (position <= 1) { // If position is 0 or negative, delete the first node currentNode = headNode; headNode = currentNode->next; if (headNode) headNode->prev = nullptr; else tailNode = nullptr; delete currentNode; return; } else if (position == getLength()) { // Delete the middle or last nodes currentNode = tailNode; tailNode = currentNode->prev; if (tailNode) tailNode->next = nullptr; else headNode = nullptr; delete currentNode; return; } else { currentNode = headNode; uint8_t currentPosition = 1; // Traverse the list to find the DoublyNode at the given position while (currentPosition < position) { previousNode = currentNode; currentNode = currentNode->next; currentPosition++; } // If the DoublyNode at the given position is found, delete it if (currentNode != nullptr) { previousNode->next = currentNode->next; if (currentNode->next) currentNode->next->prev = previousNode; if (currentNode == tailNode) tailNode = previousNode; delete currentNode; } } }