C++ Programming. Please make sure program compiles and ALL parts are completed f

Question

C++ Programming. Please make sure program compiles and ALL parts are completed for a thumbs up. Parts to be completed listed below, and I will upload all source code underneath.

config.h:

/**
* Linked List class (Lab 5) configuration file.
* Activate test #N by defining the corresponding LAB5_TESTN to have the value 1.
*/

#define LAB5_TEST1   0   // 1 means test with int instead of char
#define LAB5_TEST2   0   // Activate moveToBeginning (prog exercise 2)
#define LAB5_TEST3   0   // Activate insertBefore (prog exercise 3)

ListLinked.h:

//--------------------------------------------------------------------
//
// Laboratory 5 ListLinked.h
//
// Class declaration for the linked implementation of the List ADT
//
//--------------------------------------------------------------------

#ifndef LISTLINKED_H
#define LISTLINKED_H

#pragma warning( disable : 4290 )

#include <stdexcept>
#include <iostream>

using namespace std;

template <typename DataType>
class List {
public:
List(int ignored = 0);
List(const List& other);
List& operator=(const List& other);
~List();

void insert(const DataType& newDataItem) throw (logic_error);
void remove() throw (logic_error);
void replace(const DataType& newDataItem) throw (logic_error);
void clear();

bool isEmpty() const;
bool isFull() const;

void gotoBeginning() throw (logic_error);
void gotoEnd() throw (logic_error);
bool gotoNext() throw (logic_error);
bool gotoPrior() throw (logic_error);

DataType getCursor() const throw (logic_error);

// Programming exercise 2
void moveToBeginning () throw (logic_error);

// Programming exercise 3
void insertBefore(const DataType& newDataItem) throw (logic_error);
  
void showStructure() const;

private:
class ListNode {
public:
   ListNode(const DataType& nodeData, ListNode* nextPtr);

   DataType dataItem;
   ListNode* next;
};

ListNode* head;
ListNode* cursor;

};

#endif

ListLinked.cpp:

#include "ListLinked.h"

// ListNode member functions

template <typename DataType>
List<DataType>::ListNode::ListNode(const DataType& nodeData, ListNode* nextPtr)
{
   this->dataItem = nodeData;
   this->next = nextPtr;
}

// List member functions

template <typename DataType>
List<DataType>::List(int ignored = 0)
{
}

template <typename DataType>
List<DataType>::List(const List& other)
{
}

template <typename DataType>
List<DataType>& List<DataType>::operator=(const List& other)
{
}

template <typename DataType>
List<DataType>::~List()
{
}

template <typename DataType>
void List<DataType>::insert(const DataType& newDataItem) throw (logic_error)
{
}

template <typename DataType>
void List<DataType>::remove() throw (logic_error)
{
}

template <typename DataType>
void List<DataType>::replace(const DataType& newDataItem) throw (logic_error)
{
}

template <typename DataType>
void List<DataType>::clear()
{
}

template <typename DataType>
bool List<DataType>::isEmpty() const
{
   return false;
}

template <typename DataType>
bool List<DataType>::isFull() const
{
   return false;
}

template <typename DataType>
void List<DataType>::gotoBeginning() throw (logic_error)
{
}

template <typename DataType>
void List<DataType>::gotoEnd() throw (logic_error)
{
}

template <typename DataType>
bool List<DataType>::gotoNext() throw (logic_error)
{
   return false;
}

template <typename DataType>
bool List<DataType>::gotoPrior() throw (logic_error)
{
   return false;
}

template <typename DataType>
DataType List<DataType>::getCursor() const throw (logic_error)
{
   DataType t;
   return t;
}

template <typename DataType>
void List<DataType>::moveToBeginning () throw (logic_error)
{
}

template <typename DataType>
void List<DataType>::insertBefore(const DataType& newDataItem) throw (logic_error)
{
}

#include "show5.cpp"

show5.cpp:

//--------------------------------------------------------------------
// show5.cpp: includes implementation of showStructure
//--------------------------------------------------------------------

#include "ListLinked.h"

template <typename DataType>
void List<DataType>::showStructure() const

// Outputs the items in a list. If the list is empty, outputs
// "Empty list". This operation is intended for testing and
// debugging purposes only.

{
if ( isEmpty() )
{
cout << "Empty list" << endl;
}
else
{
   for (ListNode* temp = head; temp != 0; temp = temp->next) {
   if (temp == cursor) {
       cout << "[";
   }

   // Assumes that dataItem can be printed via << because
   // is is either primitive or operator<< is overloaded.
   cout << temp->dataItem;  

   if (temp == cursor) {
       cout << "]";
   }
   cout << " ";
   }
   cout << endl;
}
}

test5.cpp:

//--------------------------------------------------------------------
//
// Laboratory 5 test5.cpp
//
// Test program for the operations in the List ADT
//
//--------------------------------------------------------------------

#include <iostream>
#include "config.h"
#include "ListLinked.cpp"

using namespace std;

void print_help();

int main()
{
#if LAB5_TEST1
List<int> testList; // Test list
int testData; // List data item
#else
List<char> testList; // Test list
char testData; // List data item
#endif
char cmd; // Input command

print_help();

do
{
testList.showStructure(); // Output list

cout << endl << "Command: "; // Read command
cin >> cmd;
if ( cmd == '+' || cmd == '=' || cmd == '#' )
cin >> testData;

switch ( cmd )
{
case 'H' : case 'h':
print_help();
break;

case '+' : // insert
cout << "Insert " << testData << endl;
testList.insert(testData);
break;

case '-' : // remove
cout << "Remove the data item marked by the cursor"
<< endl;
testList.remove();
break;

case '=' : // replace
cout << "Replace the data item marked by the cursor "
<< "with " << testData << endl;
testList.replace(testData);
break;

case '@' : // getCursor
cout << "Element marked by the cursor is "
<< testList.getCursor() << endl;
break;

case '<' : // gotoBeginning
testList.gotoBeginning();
cout << "Go to the beginning of the list" << endl;
break;

case '>' : // gotoEnd
testList.gotoEnd();
cout << "Go to the end of the list" << endl;
break;

case 'N' : case 'n' : // gotoNext
if ( testList.gotoNext() )
cout << "Go to the next data item" << endl;
else
cout << "Failed -- either at the end of the list "
<< "or the list is empty" << endl;
break;

case 'P' : case 'p' : // gotoPrior
if ( testList.gotoPrior() )
cout << "Go to the prior data item" << endl;
else
cout << "Failed -- either at the beginning of the "
<< "list or the list is empty" << endl;
break;

case 'C' : case 'c' : // clear
cout << "Clear the list" << endl;
testList.clear();
break;

case 'E' : case 'e' : // empty
if ( testList.isEmpty() )
cout << "List is empty" << endl;
else
cout << "List is NOT empty" << endl;
break;

case 'F' : case 'f' : // full
if ( testList.isFull() )
cout << "List is full" << endl;
else
cout << "List is NOT full" << endl;
break;

#if LAB5_TEST2
case 'M' : case 'm' : // In-lab Exercise 2
cout << "Move the data item marked by the cursor to the "
<< "beginning of the list" << endl;
testList.moveToBeginning();
break;
#endif

#if LAB5_TEST3
case '#' : // In-lab Exercise 3
cout << "Insert " << testData << " before the "
<< "cursor" << endl;
testList.insertBefore(testData);
break;
#endif

case 'Q' : case 'q' : // Quit test program
break;

default : // Invalid command
cout << "Inactive or invalid command" << endl;
}
}
while ( cin && cmd != 'Q' && cmd != 'q' );

if( ! cin )
{
// This is useful if students are testing the list with ints, instead of
   // chars, and accidentally enter a non-digit char.
   cout << "cin read errror" << endl;
}

return 0;
}

void print_help()
{
cout << endl << "Commands:" << endl;
cout << " H : Help (displays this message)" << endl;
cout << " +x : Insert x after the cursor" << endl;
cout << " - : Remove the data item marked by the cursor" << endl;
cout << " =x : Replace the data item marked by the cursor with x"
<< endl;
cout << " @ : Display the data item marked by the cursor" << endl;
cout << " < : Go to the beginning of the list" << endl;
cout << " > : Go to the end of the list" << endl;
cout << " N : Go to the next data item" << endl;
cout << " P : Go to the prior data item" << endl;
cout << " C : Clear the list" << endl;
cout << " E : Empty list?" << endl;
cout << " F : Full list?" << endl;
cout << " M : Move data item marked by cursor to beginning "
<< "(" <<
#if LAB5_TEST2
   " Active "
#else
   "Inactive "
#endif
   << ": In-lab Ex. 2)" << endl;
cout << " #x : Insert x before the cursor "
<< " (" <<
#if LAB5_TEST3
   " Active "
#else
   "Inactive "
#endif
   << " : In-lab Ex. 3)" << endl;
cout << " Q : Quit the test program" << endl;
cout << endl;
}

implement the ListLinked ADT (the declaration is given in ListLinked.h)(60 points) implement the following operations constructor assignment operator, destructor insert, remove, replace, clear isFull, isEmpty gotoBeginning, gotoEnd, gotoNext, gotoPrior getCursor Homework exercises implement the functio m that removes the data item marked by the cursor and reinserts it at the beginning of the list (20 points implement the function insertBefore(..) that will insert the new data item before the cursor or if the list is empty as the first element of the list (20 points)

Explanation / Answer

#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
struct node
{
int info;
struct node *next;
}
class single_llist
{
public:
node* create_node(int);
void insert_begin();
void insert_pos();
void insert_last();
void delete_pos();
void sort();
void search();
void update();
void reverse();
void display();
single_llist()
{
start = NULL;
}
};
main()
{
int choice, nodes, element, position, i;
single_llist sl;
start = NULL;
while (1)
{
cout<<endl<<"---------------------------------"<<endl;
cout<<endl<<"Operations on singly linked list"<<endl;
cout<<endl<<"---------------------------------"<<endl;
cout<<"1.Insert Node at beginning"<<endl;
cout<<"2.Insert node at last"<<endl;
cout<<"3.Insert node at position"<<endl;
cout<<"4.Sort Link List"<<endl;
cout<<"5.Delete a Particular Node"<<endl;
cout<<"6.Update Node Value"<<endl;
cout<<"7.Search Element"<<endl;
cout<<"8.Display Linked List"<<endl;
cout<<"9.Reverse Linked List "<<endl;
cout<<"10.Exit "<<endl;
cout<<"Enter your choice : ";
cin>>choice;
switch(choice)
{
case 1:
cout<<"Inserting Node at Beginning: "<<endl;
sl.insert_begin();
cout<<endl;
break;
case 2:
cout<<"Inserting Node at Last: "<<endl;
sl.insert_last();
cout<<endl;
break;
case 3:
cout<<"Inserting Node at a given position:"<<endl;
sl.insert_pos();
cout<<endl;
break;
case 4:
cout<<"Sort Link List: "<<endl;
sl.sort();
cout<<endl;
break;
case 5:
cout<<"Delete a particular node: "<<endl;
sl.delete_pos();
break;
case 6:
cout<<"Update Node Value:"<<endl;
sl.update();
cout<<endl;
break;
case 7:
cout<<"Search element in Link List: "<<endl;
sl.search();
cout<<endl;
break;
case 8:
cout<<"Display elements of link list"<<endl;
sl.display();
cout<<endl;
break;
case 9:
cout<<"Reverse elements of Link List"<<endl;
sl.reverse();
cout<<endl;
break;
case 10:
cout<<"Exiting..."<<endl;
exit(1);
break;
default:
cout<<"Wrong choice"<<endl;
}
}
}
node *single_llist::create_node(int value)
{
struct node *temp, *s;
temp = new(struct node);
if (temp == NULL)
{
cout<<"Memory not allocated "<<endl;
return 0;
}
else
{
temp->info = value;
temp->next = NULL;   
return temp;
}
}
void single_llist::insert_begin()
{
int value;
cout<<"Enter the value to be inserted: ";
cin>>value;
struct node *temp, *p;
temp = create_node(value);
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
p = start;
start = temp;
start->next = p;
}
cout<<"Element Inserted at beginning"<<endl;
}
void single_llist::insert_last()
{
int value;
cout<<"Enter the value to be inserted: ";
cin>>value;
struct node *temp, *s;
temp = create_node(value);
s = start;
while (s->next != NULL)
{   
s = s->next;
}
temp->next = NULL;
s->next = temp;
cout<<"Element Inserted at last"<<endl;
}
void single_llist::insert_pos()
{
int value, pos, counter = 0;
cout<<"Enter the value to be inserted: ";
cin>>value;
struct node *temp, *s, *ptr;
temp = create_node(value);
cout<<"Enter the postion at which node to be inserted: ";
cin>>pos;
int i;
s = start;
while (s != NULL)
{
s = s->next;
counter++;
}
if (pos == 1)
{
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
ptr = start;
start = temp;
start->next = ptr;
}
}
else if (pos > 1 && pos <= counter)
{
s = start;
for (i = 1; i < pos; i++)
{
ptr = s;
s = s->next;
}
ptr->next = temp;
temp->next = s;
}
else
{
cout<<"Positon out of range"<<endl;
}
}
void single_llist::sort()
{
struct node *ptr, *s;
int value;
if (start == NULL)
{
cout<<"The List is empty"<<endl;
return;
}
ptr = start;
while (ptr != NULL)
{
for (s = ptr->next;s !=NULL;s = s->next)
{
if (ptr->info > s->info)
{
value = ptr->info;
ptr->info = s->info;
s->info = value;
}
}
ptr = ptr->next;
}
}
void single_llist::delete_pos()
{
int pos, i, counter = 0;
if (start == NULL)
{
cout<<"List is empty"<<endl;
return;
}
cout<<"Enter the position of value to be deleted: ";
cin>>pos;
struct node *s, *ptr;
s = start;
if (pos == 1)
{
start = s->next;
}
else
{
while (s != NULL)
{
s = s->next;
counter++;
}
if (pos > 0 && pos <= counter)
{
s = start;
for (i = 1;i < pos;i++)
{
ptr = s;
s = s->next;
}
ptr->next = s->next;
}
else
{
cout<<"Position out of range"<<endl;
}
free(s);
cout<<"Element Deleted"<<endl;
}
}
void single_llist::update()
{
int value, pos, i;
if (start == NULL)
{
cout<<"List is empty"<<endl;
return;
}
cout<<"Enter the node postion to be updated: ";
cin>>pos;
cout<<"Enter the new value: ";
cin>>value;
struct node *s, *ptr;
s = start;
if (pos == 1)
{
start->info = value;
}
else
{
for (i = 0;i < pos - 1;i++)
{
if (s == NULL)
{
cout<<"There are less than "<<pos<<" elements";
return;
}
s = s->next;
}
s->info = value;
}
cout<<"Node Updated"<<endl;
}
void single_llist::search()
{
int value, pos = 0;
bool flag = false;
if (start == NULL)
{
cout<<"List is empty"<<endl;
return;
}
cout<<"Enter the value to be searched: ";
cin>>value;
struct node *s;
s = start;
while (s != NULL)
{
pos++;
if (s->info == value)
{
flag = true;
cout<<"Element "<<value<<" is found at position "<<pos<<endl;
}
s = s->next;
}
if (!flag)
cout<<"Element "<<value<<" not found in the list"<<endl;
}
void single_llist::reverse()
{
struct node *ptr1, *ptr2, *ptr3;
if (start == NULL)
{
cout<<"List is empty"<<endl;
return;
}
if (start->next == NULL)
{
return;
}
ptr1 = start;
ptr2 = ptr1->next;
ptr3 = ptr2->next;
ptr1->next = NULL;
ptr2->next = ptr1;
while (ptr3 != NULL)
{
ptr1 = ptr2;
ptr2 = ptr3;
ptr3 = ptr3->next;
ptr2->next = ptr1;   
}
start = ptr2;
}
void single_llist::display()
{
struct node *temp;
if (start == NULL)
{
cout<<"The List is Empty"<<endl;
return;
}
temp = start;
cout<<"Elements of list are: "<<endl;
while (temp != NULL)
{
cout<<temp->info<<"->";
temp = temp->next;
}
cout<<"NULL"<<endl;
}

Related Questions

Navigate

• Browse (All)
• Browse C
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.