Question

could you implement this function please, im having issues with it.

void makeList (const ListNode::value_type [],const size_t& count)

class ListNode

{

public:

typedef int value_type;

ListNode (value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; }

  

//Assessor

value_type getDatum () const { return datum; }

ListNode const* getNext () const { return next; }

  

//Mutator

void setDatum (const value_type& d) {datum = d; }

ListNode* getNext () { return next; }

void setNext (ListNode* new_link) {next = new_link; }

  

private:

value_type datum;

ListNode* next;

};

  

  

class LinkedList

{

public:

LinkedList ();

virtual ~LinkedList ();

  

void insertItem (ListNode::value_type);

void makeList (const ListNode::value_type [],const size_t& count);

void deleteList ();

  

//The following friend function is implemented in lablinklist.cpp

friend std::ostream& operator<<(std::ostream&, const LinkedList&);

private:

ListNode* head;

};

This is the pseudocode, but i still have a hard time undertanding it.

Creating a List (makeList(const ListNode::value_type [],const size_t& count)) This function receives an array in the order that we want to add it to the linkedlist. Index 0 will be the head node, index n will be the last node.

First, create a node initialized with a data value and a NULL pointer. Set the "head" to point to the first node. Set up a current-pointer to the first node (or "head"). Get a data value for the next node. While more nodes to add { Create a new node initialized with the data value and a NULL pointer. Set the current-pointer link member ("next") to the new node. Set the current-pointer to point to the new node. Get a data value for the next node. }

Thanks.

Answer 1

//linkedList.h

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include <cstdlib>
#include<iostream>
class ListNode
{
public:
   typedef int value_type;
   ListNode(value_type d = value_type(), ListNode* n = NULL) { datum = d; next = n; }

   //Assessor
   value_type getDatum() const { return datum; }
   ListNode const* getNext() const { return next; }

   //Mutator
   void setDatum(const value_type& d) { datum = d; }
   ListNode* getNext() { return next; }
   void setNext(ListNode* new_link) { next = new_link; }

private:
   value_type datum;
   ListNode* next;
};

class LinkedList
{
public:
   LinkedList();
   virtual ~LinkedList();

   void insertItem(ListNode::value_type);
   void makeList(const ListNode::value_type[], const size_t& count);
   void deleteList();

   //The following friend function is implemented in lablinklist.cpp
   friend std::ostream& operator<<(std::ostream&, const LinkedList&);
private:
   ListNode* head;
};
#endif

-------------------------------------------------------------

//linkedList.cpp

#include "linkedlist.h"

LinkedList::LinkedList()
{
   head = NULL;
}
LinkedList::~LinkedList()
{
   ListNode *tmp = head;
   while (tmp != NULL)
   {
       head = head->getNext();
       delete tmp;
       tmp = head;
   }
}

void LinkedList::insertItem(ListNode::value_type item)
{
   ListNode *newNode,*cur = head;
   newNode = new ListNode;
   newNode->setDatum(item);
   newNode->setNext(NULL);
   if (head == NULL)
   {
       head = newNode;
   }
   else
   {

       while (cur->getNext() != NULL)
       {
           cur = cur->getNext();
       }
       cur->setNext(newNode);
   }

}

void LinkedList::makeList(const ListNode::value_type num[], const size_t& count)
{
   int i = 0;
   while ( i < count)
   {
       insertItem(num[i++]);
   }
}

void LinkedList::deleteList()
{
   ListNode *tmp = head;
   while (tmp != NULL)
   {
       head = head->getNext();
       delete tmp;
       tmp = head;
   }
}

std::ostream& operator<<(std::ostream& os, const LinkedList &srcList) {

   //Set a current-pointer to the "head".
   ListNode* cursor = srcList.head;

   //While current-pointer is not NULL
   while (cursor != NULL)
   {
       //Print the data member ("datum") of the current node
       os << "->[" << cursor->getDatum() << "]";
       //Set the current-pointer to the "next" node in the list.
       cursor = cursor->getNext();
   }
   //Print out a basic termination symbol
   std::cout << "--X" << std::endl;

   return os;

}

---------------------------------------

//main.cpp

#include <iostream>
#include "linkedlist.h"

using namespace std;

int main() {

   LinkedList list1;

   //Test of adding items out of order
   list1.insertItem(5);
   list1.insertItem(20);
   list1.insertItem(10);
   cout << "After adding 5,20,10 to list ,List contains" << endl;
   cout << list1 << endl;

   //Test of deleting entire list
   list1.deleteList();
   cout << "After deleteing list,List contains" << endl;
   cout << list1 << endl;

   //Add items again in same order as before
   cout << "After adding 5,20,10 to list ,List contains" << endl;
   list1.insertItem(5);
   list1.insertItem(20);
   list1.insertItem(10);
   cout << list1 << endl;

   //Now replace list with a new one in a specific order
   int pow2[] = { 1, 2, 4, 8, 16, 32, 16, 8, 4, 2, 1 };
   list1.makeList(pow2, sizeof(pow2) / sizeof(int));
   cout << "After calling makeList function" << endl;
   cout << list1 << endl;

   //Returning a non-zero number, if not 3, then we know it seg-faulted
   return 3;
}

-----------------------------------------------------------------------------------------------------------

After adding 5,20,10 to list ,List contains
->[5]->[20]->[10]--X

After deleteing list,List contains
--X

After adding 5,20,10 to list ,List contains
->[5]->[20]->[10]--X

After calling makeList function
->[5]->[20]->[10]->[1]->[2]->[4]->[8]->[16]->[32]->[16]->[8]->[4]->[2]->[1]--X