Q2 - 25 pts) Add a member function mergeList to the Singly Linked List-based imp
ID: 3870896 • Letter: Q
Question
Q2 - 25 pts) Add a member function mergeList to the Singly Linked List-based implementation of the List ADT. The member function takes as input a List object (representing the list of smaller size) as parameter and appends it to the List object (representing the list of larger size) on which the function will be called.
Consider largerIntegerList and smallerIntegerList to be the two List objects in the main function. The
main function should call largerIntegerList.mergeList(smallerIntegerList) and then print the contents of the largerIntegerList using the IterativePrint( ) member function by calling largerIntegerList.IterativePrint( ) from main. The mergeList member function will append the elements of the smallerIntegerList to the end of the largerIntegerList. Use the Singly Linked List code for Question 2 attached in this project description.
For example:
If largerIntegerList is 78 --> 14 --> 52 --> 96 --> 52 --> 63 and
the smallerIntegerList is 44 --> 22 --> 11, then the contents of the largerIntegerList after the merger should be: 78 --> 14 --> 52 --> 96 --> 52 --> 63 --> 44 --> 22 --> 11.
To test your code (and take a screenshot), let the size of the largerIntegerList be any value from 6 to 10 and the size of the smallerIntegerList be any value from 3 to 5.
LIST
#include <iostream>
using namespace std;
// implementing the dynamic List ADT using Linked List
class Node{
private:
int data;
Node* nextNodePtr;
public:
Node(){}
void setData(int d){
data = d;
}
int getData(){
return data;
}
void setNextNodePtr(Node* nodePtr){
nextNodePtr = nodePtr;
}
Node* getNextNodePtr(){
return nextNodePtr;
}
};
class List{
private:
Node *headPtr;
public:
List(){
headPtr = new Node();
headPtr->setNextNodePtr(0);
}
Node* getHeadPtr(){
return headPtr;
}
bool isEmpty(){
if (headPtr->getNextNodePtr() == 0)
return true;
return false;
}
void insert(int data){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
while (currentNodePtr != 0){
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
}
Node* newNodePtr = new Node();
newNodePtr->setData(data);
newNodePtr->setNextNodePtr(0);
prevNodePtr->setNextNodePtr(newNodePtr);
}
void insertAtIndex(int insertIndex, int data){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == insertIndex)
break;
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
Node* newNodePtr = new Node();
newNodePtr->setData(data);
newNodePtr->setNextNodePtr(currentNodePtr);
prevNodePtr->setNextNodePtr(newNodePtr);
}
int read(int readIndex){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == readIndex)
return currentNodePtr->getData();
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
return -1; // an invalid value indicating
// index is out of range
}
void modifyElement(int modifyIndex, int data){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == modifyIndex){
currentNodePtr->setData(data);
return;
}
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
}
void deleteElement(int deleteIndex){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
Node* nextNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == deleteIndex){
nextNodePtr = currentNodePtr->getNextNodePtr();
break;
}
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
prevNodePtr->setNextNodePtr(nextNodePtr);
}
void IterativePrint(){
Node* currentNodePtr = headPtr->getNextNodePtr();
while (currentNodePtr != 0){
cout << currentNodePtr->getData() << " ";
currentNodePtr = currentNodePtr->getNextNodePtr();
}
cout << endl;
}
// add code to the member function mergeList(List)
};
int main(){
int largerListSize;
cout << "Enter the number of elements you want to insert in the larger list: ";
cin >> largerListSize;
List largerIntegerList;
for (int i = 0; i < largerListSize; i++){
int value;
cout << "Enter element # " << i << " : ";
cin >> value;
largerIntegerList.insertAtIndex(i, value);
}
cout << "Contents of the Larger List: ";
largerIntegerList.IterativePrint();
int smallerListSize;
cout << "Enter the number of elements you want to insert in the smaller list: ";
cin >> smallerListSize;
List smallerIntegerList;
for (int i = 0; i < smallerListSize; i++){
int value;
cout << "Enter element # " << i << " : ";
cin >> value;
smallerIntegerList.insertAtIndex(i, value);
}
cout << "Contents of the Smaller List: ";
smallerIntegerList.IterativePrint();
largerIntegerList.mergeList(smallerIntegerList);
cout << "Contents of the merged list: ";
largerIntegerList.IterativePrint();
return 0;
}
Explanation / Answer
#include <iostream>
using namespace std;
// implementing the dynamic List ADT using Linked List
class Node{
private:
int data;
Node* nextNodePtr;
public:
Node(){}
void setData(int d){
data = d;
}
int getData(){
return data;
}
void setNextNodePtr(Node* nodePtr){
nextNodePtr = nodePtr;
}
Node* getNextNodePtr(){
return nextNodePtr;
}
};
class List{
private:
Node *headPtr;
public:
List(){
headPtr = new Node();
headPtr->setNextNodePtr(0);
}
Node* getHeadPtr(){
return headPtr;
}
bool isEmpty(){
if (headPtr->getNextNodePtr() == 0)
return true;
return false;
}
void insert(int data){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
while (currentNodePtr != 0){
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
}
Node* newNodePtr = new Node();
newNodePtr->setData(data);
newNodePtr->setNextNodePtr(0);
prevNodePtr->setNextNodePtr(newNodePtr);
}
void insertAtIndex(int insertIndex, int data){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == insertIndex)
break;
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
Node* newNodePtr = new Node();
newNodePtr->setData(data);
newNodePtr->setNextNodePtr(currentNodePtr);
prevNodePtr->setNextNodePtr(newNodePtr);
}
int read(int readIndex){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == readIndex)
return currentNodePtr->getData();
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
return -1; // an invalid value indicating
// index is out of range
}
void modifyElement(int modifyIndex, int data){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == modifyIndex){
currentNodePtr->setData(data);
return;
}
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
}
void deleteElement(int deleteIndex){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = headPtr;
Node* nextNodePtr = headPtr;
int index = 0;
while (currentNodePtr != 0){
if (index == deleteIndex){
nextNodePtr = currentNodePtr->getNextNodePtr();
break;
}
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
index++;
}
prevNodePtr->setNextNodePtr(nextNodePtr);
}
void IterativePrint(){
Node* currentNodePtr = headPtr->getNextNodePtr();
while (currentNodePtr != 0){
cout << currentNodePtr->getData() << " ";
currentNodePtr = currentNodePtr->getNextNodePtr();
}
cout << endl;
}
// add code to the member function mergeList(List)
void mergeList(List smallList){
Node* currentNodePtr = headPtr->getNextNodePtr();
Node* prevNodePtr = 0;
while (currentNodePtr != 0){
prevNodePtr = currentNodePtr;
currentNodePtr = currentNodePtr->getNextNodePtr();
}
prevNodePtr->setNextNodePtr(smallList.getHeadPtr()->getNextNodePtr());
}
};
int main(){
int largerListSize;
cout << "Enter the number of elements you want to insert in the larger list: ";
cin >> largerListSize;
List largerIntegerList;
for (int i = 0; i < largerListSize; i++){
int value;
cout << "Enter element # " << i << " : ";
cin >> value;
largerIntegerList.insertAtIndex(i, value);
}
cout << "Contents of the Larger List: ";
largerIntegerList.IterativePrint();
int smallerListSize;
cout << "Enter the number of elements you want to insert in the smaller list: ";
cin >> smallerListSize;
List smallerIntegerList;
for (int i = 0; i < smallerListSize; i++){
int value;
cout << "Enter element # " << i << " : ";
cin >> value;
smallerIntegerList.insertAtIndex(i, value);
}
cout << "Contents of the Smaller List: ";
smallerIntegerList.IterativePrint();
largerIntegerList.mergeList(smallerIntegerList);
cout << "Contents of the merged list: ";
largerIntegerList.IterativePrint();
return 0;
}
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.