Diferença de duas pilhas

Olá, tenho uma implementação de classe de pilha na linguagem C++ usando uma lista encadeada simples. O código também contém operações como construtor, destrutor, pop, push, top, exibindo as pilhas e verificando se uma pilha está vazia ou não. Além disso, há uma parte para exibir interseção, união e diferença de duas pilhas usando essas operações listadas. Embora as partes de interseção e união funcionem bem no código e forneçam a saída desejada, há um problema com a exibição da diferença de duas pilhas que não consegui descobrir. Para esta parte, quero exibir elementos que S1 tem e S2 não tem. Eu agradeceria se você pudesse me ajudar.

Aqui estão minhas duas pilhas:

S1 = {maçã, banana, cereja}

S2 = {banana, cereja, tâmara}

Saída esperada para diferença:

S5 (Diferença) = {maçã}

Mas em vez disso, estou recebendo esta saída:

S5 (Diferença) = {maçã, banana, cereja}

#include <iostream>
#include <string>
using namespace std;

// Node structure for singly linked list
struct Node {
    string data;
    Node* next;
};

// Stack class implementation using singly linked list
class Stack {
private:
    Node* top;

public:
    // Constructor
    Stack() : top(nullptr) {}

    // Destructor
    ~Stack() {
        while (!isEmpty()) {
            pop();
        }
    }

    // Push operation
    void push(const string& data) {
        Node* newNode = new Node{data, top};
        top = newNode;
    }

    // Pop operation
    string pop() {
        if (isEmpty()) {
            cout << "Stack is empty!" << endl;
            return "";
        }
        string data = top->data;
        Node* temp = top;
        top = top->next;
        delete temp;
        return data;
    }

    // Top operation
    string getTop() const {
        if (isEmpty()) {
            return "";
        }
        return top->data;
    }

    // Display all elements in the stack
    void displayStack() const {
        Node* current = top;
        while (current) {
            cout << current->data << " ";
            current = current->next;
        }
        cout << endl;
    }

    // Check if stack is empty
    bool isEmpty() const {
        return top == nullptr;
    }

    // Find operation
    bool find(const string& data) const {
        Node* current = top;
        while (current) {
            if (current->data == data) {
                return true;
            }
            current = current->next;
        }
        return false;
    }
};

// Function to compute intersection of two stacks
Stack intersection(Stack& s1, Stack& s2) {
    Stack result;
    Stack temp;  // Temporary stack to preserve s1 during traversal

    while (!s1.isEmpty()) {
        string element = s1.pop();
        temp.push(element);
        if (s2.find(element)) {
            result.push(element);
        }
    }

    // Restore original stack s1
    while (!temp.isEmpty()) {
        s1.push(temp.pop());
    }

    return result;
}

// Function to compute union of two stacks
Stack unionStacks(Stack& s1, Stack& s2) {
    Stack result;

    Stack temp;  // Temporary stack to preserve s1 during traversal

    while (!s1.isEmpty()) {
        string element = s1.pop();
        temp.push(element);
        result.push(element);
    }

    // Restore original stack s1
    while (!temp.isEmpty()) {
        s1.push(temp.pop());
    }

    while (!s2.isEmpty()) {
        string element = s2.pop();
        if (!result.find(element)) {  // Avoid duplicate entries
            result.push(element);
        }
    }

    return result;
}

Stack difference(Stack& s1, Stack& s2) {
    Stack result;

    Stack temp;  // Temporary stack to preserve s1 during traversal

    while (!s1.isEmpty()) {
        string element = s1.pop();
        temp.push(element);
        if (s2.find(element)) {
            continue;
        }
        else {
            result.push(element);
        }
    }

    // Restore original stack s1
    while (!temp.isEmpty()) {
        s1.push(temp.pop());
    }

    return result;
}

// Main function to test functionality
int main() {
    Stack s1, s2;

    // Push elements into stacks S1 and S2
    s1.push("apple");
    s1.push("banana");
    s1.push("cherry");

    s2.push("banana");
    s2.push("cherry");
    s2.push("date");

    cout << "Stack S1: ";
    s1.displayStack();

    cout << "Stack S2: ";
    s2.displayStack();

    // Intersection of S1 and S2
    Stack s3 = intersection(s1, s2);
    cout << "Intersection (S3): ";
    s3.displayStack();

    // Union of S1 and S2
    Stack s4 = unionStacks(s1, s2);
    cout << "Union (S4): ";
    s4.displayStack();
    
    // Difference of S1 and S2
    Stack s5 = difference(s1, s2);
    cout << "Difference (S5): ";
    s5.displayStack();

    return 0;
}

Para encontrar os elementos que S1 tem e S2 não (é isso que estou tentando fazer), tentei colocar os elementos em outra pilha.