Using Search, Union and Intersection in a Linked List, Program Crash

I'm workng on a project that I thought I understood and it turns out that I have no idea what I'm doing. The program is supposed to list different set of numbers out of an existing set, implemeting union and intersection. The program builds with no errirs and partially runs but then crashes. If someone can point out what I've done wrong and how to fit it I would be much obliged. Here is my code so far.

// list.cpp
// simple linked list program

#include <stdlib.h>
#include <string>
#include <iostream>

using std::cout;
using std::string;

// node object for the linked list
struct Node {
    int data;
    Node* link;
};

// implement a singly linked list
class LinkedList {protected:
    Node* front;        // pointer to the front of the linked list
    Node* back;         // pointer to the last node in the linked list

public:
    // constructs an empty list
    LinkedList() {
        front = back = NULL;
    }

	// search the list for a target value
    // return index if found or -1 if not found
    int Search(int targetVal) {
        Node* p;
        int count = 0;
        for (p = front; p != NULL; p = p->link) {
            if (p->data == targetVal) {
                return count;
            }
            count++;
        }
        return -1;
    }
	
    // deletes the list
    ~LinkedList() {
        // remove objects from the list as long as list is not empty
        while(Length() > 0) {
            RemoveFront();
        }
    }

    // inserts a node at the front of the list
    void InsertFront(int newValue) {
        Node* newNode = new Node;
        newNode->data = newValue;
        if (front == NULL) {
            // list must be empty so make front & back point to new node
            front = back = newNode;
            newNode->link = NULL;
        } else {
            // list is not empty so insert between front and first node
            newNode->link = front;
            front = newNode;
        }
    }

    // removes a node from the front of the list
    int RemoveFront() {
        int returnVal;
        Node *temp;
        if (front != NULL) {
            // list is not empty so remove & return first node
            returnVal = front->data;
            temp = front;
            front = front->link;
        } else {
            // list is empty just return 0
            returnVal = 0;
        }
        return returnVal;
    }

    // returns the length of the list
    int Length() {
        Node* p;
        int count = 0;
        // loop through each node in the list until we find a null value
        for (p = front; p != NULL; p = p->link) {
            count++;
        }
        return count;
    }

    // outputs a string containing all the data values in the list
    void Output() {
        Node* p;
        // loop through each node in the list until we find a null value
        for (p = front; p != NULL; p = p->link) {
            cout << p->data << ", ";
        }
    }
};

// use inheritance to create a Set class from the LinkedList class
class Set : public LinkedList {
public:
    // insert a new value only if it is unique (not already in the set)
    void Insert(int newValue) {
		int duplicate = Search(newValue);
		if (duplicate == -1)
			InsertFront(newValue);
    }

    // make this the union of two sets
    void Union(Set& a, Set& B)/> {
		Node*p;
		for(p = a.front; p != NULL; p = p->link)
		{
			Insert(p->data);
		}
		for(p = b.front; p != NULL; p = p->link)
		{
			Set::Insert(p->data);
		}
	}

    // make this the intersection of two sets
    void Intersection(Set& a, Set& B)/> {
		Node*p;
		Node*q;
		for(p = a.front; p != NULL; p = p->link)
		{
			for(q = b.front; p != NULL; p = p->link)
			{
				if (p == q)
				{
					Insert(p->data);
				}
			}
		}
	}
};


int main() {
    Set setA, setB, setUnion, setIntersection;

    setA.Insert(5);
    setA.Insert(2);
    setA.Insert(3);
    setA.Insert(5);
    setA.Insert(2);

    cout << "Contents of setA: ";
    setA.Output();
    cout << "\n\n";

    setB.Insert(1);
    setB.Insert(2);
    setB.Insert(4);

    cout << "Contents of setB: ";
    setB.Output();
    cout << "\n\n";

    setUnion.Union(setA, setB);
    cout << "Contents of setA union setB: ";
    setUnion.Output();
    cout << "\n\n";

    setIntersection.Intersection(setA, setB);
    cout << "Contents of setA intersection setB: ";
    setIntersection.Output();
    cout << "\n\n";
}