How to make an intersection function with linked lists? - c++

Question

Here is the linked lists code, so how to make two different lists and display the intersection between them?
For example there is two linked lists called L1 and L2, so how to implement a function that displays the intersection of these two lists, like L1 has 1,2,3,4,5 and L2 has 11,3,4
so the result would be 3,4.
#include <iostream>
using namespace std;
#include "Node.h"
class DoublyLinkedList{
private:
Node* head;
Node* tail;
Node* list;
int elementCount;
public:
DoublyLinkedList(){
head = tail = list = NULL;
elementCount = 0;
}
void insertAtFront(int item){
elementCount++;
Node* newNode;
newNode = new Node;
newNode->data = item;
list = head;
if(list == NULL) {
head = newNode;
tail = head;
return;
}
newNode->next = head;
head->prev = newNode;
head = newNode;
head->prev = tail;
tail->next = head;
}
void insertAtEnd(int item){
elementCount++;
Node* newNode;
newNode = new Node;
newNode->data = item;
list = head;
if(list == NULL){
head = newNode;
tail = head;
return;
}
tail->next = newNode;
newNode->prev = tail;
tail = newNode;
head->prev = tail;
tail->next = head;
}
bool insertAtIndex(int item, int index){
if(index > elementCount){
cout << "Invalid index" << endl;
return false;
}
else if(index == 0){
insertAtFront(item);
}
else if(index == elementCount){
insertAtEnd(item);
}
else {
Node* newNode = new Node;
newNode->data = item;
list = getNodeAt(index - 1);
newNode->next = list->next;
list->next->prev = newNode;
list->next = newNode;
newNode->prev = list;
elementCount++;
}
return true;
}
};

Answer 1

Since this is a learning assignment, here is a general description of the approach:
Define a function bool contains(int value) const that takes an int value and returns true when the list contains the specified value; this function will have a loop in it.
Define a function DoublyLinkedList intersectWith(DoublyLinkedList& other) const that produces the intersection by following the algorithm below:
Create a new DoublyLinkedList result
For each item of this list, call other.contains(node.data)
If the function returned true, check that result.contains(node.data) returns false to eliminate duplicates
If other.contains(node.data) && !result.contains(node.data), add node.data to result
Continue to the next node until this list is exhausted
Return the result list.