iterative and recursive find() and filter(). fix errors.

pr6.cpp

@@ -17,9 +17,9 @@ public:
         : name(n), capital(c), language(l), population(p), area(a) {}
 
     friend ostream& operator<<(ostream& os, const State& state) {
-        os << "State: " << state.name << ", Capital: " << state.capital 
+        os << "State: " << state.name << ", Capital: " << state.capital
-           << ", Language: " << state.language << ", Population: " << state.population 
+            << ", Language: " << state.language << ", Population: " << state.population
-           << ", Area: " << state.area;
+            << ", Area: " << state.area;
         return os;
     }
 
@@ -187,7 +187,6 @@ public:
     using LinkedList<T>::isEmpty;
 };
 
-// New class definitions for Doubly Linked List Elements and Doubly Linked Stack
 template<class T>
 class DoublyLinkedElement : public Element<T> {
 protected:
@@ -213,6 +212,8 @@ class DoublyLinkedStack : public SinglyLinkedListStack<T> {
 public:
     DoublyLinkedStack() : SinglyLinkedListStack<T>() {}
 
+    using LinkedList::head;
+
     virtual Element<T>* push(const T& value) override {
         DoublyLinkedElement<T>* newElement = new DoublyLinkedElement<T>(value);
         if (this->head == nullptr) {
@@ -315,30 +316,54 @@ public:
         this->count--;
     }
 
-    // Find the first element with the specified value
+    // Iterative version of find
     Element<T>* find(const T& value) const {
-        DoublyLinkedElement<T>* current = static_cast<DoublyLinkedElement<T>*>(this->head);
+        //DoublyLinkedElement<T>* current = static_cast<DoublyLinkedElement<T>*>(this->head);
+        Element<T>* current = this->head;
         while (current != nullptr) {
             if (current->getInfo() == value) {
                 return current;
             }
-            current = static_cast<DoublyLinkedElement<T>*>(current->getNext());
+            current = current->getNext(); //static_cast<DoublyLinkedElement<T>*>(current->getNext());
         }
         return nullptr;
     }
 
-    // Find all elements that satisfy the given condition
+    // Recursive version of find
+    Element<T>* find_recursive(const T& value, DoublyLinkedElement<T>* current) const {
+        if (current == nullptr) {
+            return nullptr;
+        }
+        if (current->getInfo() == value) {
+            return current;
+        }
+        return find_recursive(value, static_cast<DoublyLinkedElement<T>*>(current->getNext()));
+    }
+
+    // Iterative version of filter
     void filter(function<bool(const T&)> condition) const {
-        DoublyLinkedElement<T>* current = static_cast<DoublyLinkedElement<T>*>(this->head);
+        //DoublyLinkedElement<T>* current = static_cast<DoublyLinkedElement<T>*>(this->head);
+        Element<T>* current = this->head;
         while (current != nullptr) {
             if (condition(current->getInfo())) {
                 cout << current->getInfo() << " ";
             }
-            current = static_cast<DoublyLinkedElement<T>*>(current->getNext());
+            current = current->getNext();  //static_cast<DoublyLinkedElement<T>*>(current->getNext());
         }
         cout << endl;
     }
 
+    // Recursive version of filter
+    void filter_recursive(function<bool(const T&)> condition, DoublyLinkedElement<T>* current) const {
+        if (current == nullptr) {
+            return;
+        }
+        if (condition(current->getInfo())) {
+            cout << current->getInfo() << " ";
+        }
+        filter_recursive(condition, static_cast<DoublyLinkedElement<T>*>(current->getNext()));
+    }
+
     // Overloading the output stream operator
     friend ostream& operator<<(ostream& os, const DoublyLinkedStack& stack) {
         DoublyLinkedElement<T>* current = static_cast<DoublyLinkedElement<T>*>(stack.head);
@@ -388,9 +413,21 @@ int main() {
         cout << "Element with value 99 not found" << endl;
     }
 
+    found = stack.find_recursive(3, static_cast<DoublyLinkedElement<int>*>(stack.head));
+    if (found) {
+        cout << "Found element with value 3 using recursive find: " << found->getInfo() << endl;
+    }
+    else {
+        cout << "Element with value 3 not found using recursive find" << endl;
+    }
+
     cout << "Filtering elements greater than 2: ";
     stack.filter([](const int& value) { return value > 2; });
 
+    cout << "Filtering elements greater than 2 using recursive filter: ";
+    stack.filter_recursive([](const int& value) { return value > 2; }, static_cast<DoublyLinkedElement<int>*>(stack.head));
+    cout << endl;
+
     cout << "Element at index 1: " << stack[1] << endl;
 
     while (!stack.isEmpty()) {