Shuffling two singly linked lists [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 2 years ago.
Improve this question
I have a task where I need to design and implement a class template using singly-linked list:
template <typename Key, typename Info> class Sequence { // ... // implemented using a singly-linked list }
The second part of the task comes after the main implementation, which is to create a function 'shuffle' To test flexibility of the class template above.
template <typename Key, typename Info> Sequence<Key, Info> shuffle ( const Sequence<Key, Info> & source1, int startIndex1, int length1, const Sequence<Key, Info> & source2, int startIndex2, int length2)
The function template shuffle should produce a sequence from two input sequences by interleaving subsequences of lengths length1 and length2 respectively. The subsequences should start at positions startIndex1 and startIndex2 respectively and continue till the ends of source sequences.
Let’s have an example with sequences, where keys are presented with colours distinguishing the source sequences
RESULT = shuffle ( source1, 3, 3, source2, 1, 2)
I have so far implemented everything that is necessary for a class template using singly-linked list.
The only part I need help implementing is the shuffle function described above. here's my code so far:
#include <iostream>
using namespace std;
template < typename Key, typename Info > class Sequence;
template < typename Key, typename Info >
Sequence <Key, Info> operator+ (const Sequence < Key, Info > &a,
const Sequence < Key, Info > &b);
template < typename Key, typename Info > class Sequence
{
private:
struct Node
{
Key ID;
Info information;
Node *next;
};
Node *head; // it's a singly linked list, but requires both head & tail in order to use the insert before& after function
Node *tail;
int numberOfNode;
void removeAll () //because c++ does not remove anything automatically, needs to remove all
{
if (head == NULL)
return;
Node *NodeToDelete = head;
while (NodeToDelete != NULL)
{
head = head->next;
delete[]NodeToDelete;
delete NodeToDelete;
NodeToDelete = head; //now the first node of the list is gone, nodeToDelete is the second node
}
tail = NULL;
numberOfNode = 0;
};
void copyAll (const Sequence < Key, Info > &s)
{
head = NULL;
tail = NULL;
numberOfNode = 0;
if (s.head == NULL)
return;
Node *NodeToCopy = s.head;
while (NodeToCopy)
{
push_back (NodeToCopy->ID, NodeToCopy->information);
NodeToCopy = NodeToCopy->next;
}
};
public:
Sequence ()
{
head = NULL;
tail = NULL;
numberOfNode = 0;
}
~Sequence ()
{
removeAll ();
}
Sequence (const Sequence < Key, Info > &s)
{
copyAll (s);
}
Sequence & operator= (const Sequence < Key, Info > &s)
{
if (this == &s)
return *this;
removeAll ();
copyAll (s);
return *this;
}
bool operator== (const Sequence < Key, Info > &s) const
{
if (size() != s.size())
return false;
Node *NodeToCompare = s.head;
Node *comparedNode = head;
while (NodeToCompare != NULL)
{
if (comparedNode->ID == NodeToCompare->ID)
{
NodeToCompare = NodeToCompare->next;
comparedNode = comparedNode->next;
}
else
return false;
}
return true;
}
bool operator != (const Sequence < Key, Info > &s) const
{
//writing the interior of the function simply as a return value
//in the end, true& false values are outputted as 1/0, bool returns 1/0
return !(*this == s);
}
//+= operator processes and returns everything to the object itself
Sequence < Key, Info > &operator += (const Sequence < Key, Info > &s)
{
if (s.empty ())
return *this;
if (this == &s)
{
*this = *this + s;
return *this;
}
Node *NodeToCopy = s.head;
while (NodeToCopy != NULL)
{
push_back (NodeToCopy->ID, NodeToCopy->information);
NodeToCopy = NodeToCopy->next;
}
return *this;
}
//operator + can add multiple things at the same time. Doesn't necessarily need to obtain a sum
Sequence < Key, Info > &operator + (const Sequence < Key, Info > &a)
{
Node *temp = a.head;
while (temp != NULL)
{
push_back (temp->ID, temp->information);
temp = temp->next;
}
return *this;
}
void insertAfter (const Key &location, const Key & newID,
const Info & newInfo)
{
Node *NodeToAdd = new Node (newID, newInfo, NULL);
if (head == NULL)
{
head = NodeToAdd;
tail = head;
numberOfNode++;
return;
}
//We get the position of head from constructor, once we add sth there
Node *current = head; // looking for position location we will place new created Node
while (current->next != NULL && current->ID != location)
current = current->next;
//Connecting between the new node, and the second half of the node first, so that when splitting the link, the second half won't be lost
NodeToAdd->next = current->next;
//Now, disconnecting the link between the current node to the second half of the link, so the new node can be the only link that connect them 2.
current->next = NodeToAdd; // if we want to add to the end of the list we will need to set tail pointer correctly
if (!NodeToAdd->next)
tail = NodeToAdd;
numberOfNode++;
}
void insertBefore (const Key & location, const Key & newID,
const Info & newInfo)
{
Node *NodeToAdd = new Node (newID, newInfo, NULL);
Node *current = head;
Node *previous = NULL; // looking for position location we will place new created Node
while (current != NULL && current->ID != location)
{
previous = current;
current = current->next;
} // we want to add at the beginning or we want to add first Node
if (!previous)
{
NodeToAdd->next = head;
head = NodeToAdd;
if (!tail)
tail = head;
}
else
{
NodeToAdd->next = previous->next;
previous->next = NodeToAdd; // if we want to add to the end of the list we will need to set tail pointer correctly
if (!NodeToAdd->next)
tail = NodeToAdd;
}
numberOfNode++;
}
//add Node in the end of the list
void push_back (const Key & newID, const Info & newInfo)
{
Node *NodeToAdd = new Node ();
NodeToAdd->ID = newID;
NodeToAdd->information = newInfo;
NodeToAdd->next = NULL;
if (head == NULL)
{
head = NodeToAdd;
tail = head;
}
else
{
tail->next = NodeToAdd;
tail = tail->next;
}
numberOfNode++;
}
//add Node in front of the list
void push_front (const Key & newID, const Info & newInfo)
{
Node *NodeToAdd = new Node (newID, newInfo, head);
if (head == NULL)
{
head = NodeToAdd;
tail = head;
}
else
head = NodeToAdd;
numberOfNode++;
}
bool remove (const Key & location)
{
if (head == NULL)
return false;
Node *NodeToDelete = head;
Node *previous = NULL; // looking for position of Node to be deleted
while (NodeToDelete != NULL && NodeToDelete->ID != location)
{
previous = NodeToDelete;
NodeToDelete = NodeToDelete->next;
} // if Node is found
if (NodeToDelete)
{ // if we want to delete the first Node
if (!previous)
{
head = head->next;
delete NodeToDelete;
numberOfNode--;
if (size () == 0)
tail = NULL;
}
else
{
previous->next = NodeToDelete->next;
delete NodeToDelete;
numberOfNode--; // if we have deleted tail Node
if (!previous->next)
tail = previous;
}
return true;
} // Node not found
else
return false;
}
bool positionKey (int place) const
{
//head isn't empty, and the place is a valid value
if (head != NULL && place >= 0)
{
Node *temp = head;
int i = 0;
while (i < place && temp != NULL)
{
temp = temp->next;
++i;
}
if (temp != NULL)
return true;
}
return false;
}
Key & positionKeyAt (int place) const
{
Node *temp = head;
int i = 0;
while (i < place && temp != NULL)
{
temp = temp->next;
++i;
}
return temp->ID;
}
bool positionInfo (int place) const
{
if (head != NULL && place >= 0)
{
Node *temp = head;
int i = 0;
while (i < place && temp != NULL)
{
temp = temp->next;
++i;
}
if (temp != NULL)
return true;
}
return false;
}
Info & positionInfoAt (int place) const
{
Node *temp = head;
int i = 0;
while (i < place && temp != NULL)
{
temp = temp->next;
++i;
}
return temp->information;
}
void erase ()
{
removeAll ();
}
void printAll () const
{
Node *current = head;
cout << "Printing sequence!" << endl;
while (current != NULL)
{
if (current->next == NULL)
{
cout << "ID: " << current->ID;
cout << " Info: " << current->information << endl;
cout << "______END______" << endl;
}
else
{
cout << "ID: " << current->ID;
cout << " Info: " << current->information << endl;
}
current = current->next;
}
}
int size () const
{
return numberOfNode;
}
bool empty () const
{
return numberOfNode == 0;
}
};
template <typename Key, typename Info> Sequence<Key, Info>
shuffle ( const Sequence<Key, Info> & source1, int startIndex1, int length1,
const Sequence<Key, Info> & source2, int startIndex2, int length2){
//Here is where i need help
}
int main ()
{
Sequence <int, int>seq1;
Sequence <int, int>seq2;
return 0;
}

Answer 1

The interleaving is the easy part. Given two input sequences and an output sequence:
while ((inputSeq1 has content) or (inputSeq2 has content))
{
for (int i = 0; (inputSeq1 has content) && i < 3; i++)
{
remove item from inputSeq1
append to outputSeq
}
for (int i = 0; (inputSeq2 has content) && i < 2; i++)
{
remove item from inputSeq2
append to outputSeq
}
}
That's the basic idea. You don't say whether you should stop the interleaving if one of the lists runs out of items, so I assumed you wanted everything.