Can you give me a time frame and price for this assignment?CSE 240 – Assignment 6 Points: 50 pts ...

Question

Can you give me a time frame and price for this assignment?CSE 240 – Assignment 6  Points: 50 pts  Topics:  • C/C++ Syntax  • Pointers  • Functions  • Dynamic Allocation of Memory  • Data Structures: Linked Lists  • Object Orientation  Overall Specifications:  You are to create a Linked List or Binary Search Tree data structure from  scratch.  This structure should be Templated so that any data could be stored  within it.  For a maximum of B on specifications – you can make your structure  non-templated – meaning it stores only the data required for the  problems.  The primary goal of this assignment is to make a Linked List that you can use and  re-use.  The Linked List itself is the majority of the specifications grade.  Specifications Scoring Breakdown:   Templated Linked List/BST + Problem – 100% of specifications  Templated Linked List/BST only – 80% of specifications  Untemplated Linked List/BST + Problem – 80% of specifications  Untemplated Linked List/BST only – 70% of specifications ** BIG GIANT NOTE – TEMPLATES AND FILES **   When you use a templated type in C++ ALL templated code must be done in the .h  file.  This means that ALL of your methods will be defined in the .h file as well  as your class.  You should still forward declare Classes above then Methods below.  Your .h file should have your LinkedList/BST class and your Node class and the  method definitions for both.  Remember to use your :: operator correctly.  Feel free to use friendship if needed.   Option 1  Zombie Conga Party! - Linked Lists  You will create a Linked List Class and a Node Class  The Linked List should contain the following methods in its public interface:  NOTE: T stands for the template data type, so T data means the variable of type T  (whatever T is)  • Constructor  • Destructor  • AddToFront(T data) – create a node containing T data and add it to the front of the  list  • AddToEnd(T data) – create a node containing T data and add it to the end of the  list  • AddAtIndex(T data, int index) – create a node containing T data and add it to the  list at index.  The new node containing the data will be the #index node in the  list. Return boolean for success or failure (optional: you could also return an  integer with failure codes since this method can fail multiple ways)  • RemoveFromFront() – Delete first item and return its contents  • RemoveFromEnd() – Delete last item and return its contents  • RemoveTheFirst(T data) – find first instance of T data and remove it  • RemoveAllOf(T data) – find each instance of T data and remove it  • ElementExists(T data) – Returns a T/F if element exists in list  • Find(T data) – Look for data in the list, return a pointer to its node  • IndexOf(T data) – returns an index of the item in the list (zero-based)  • RetrieveFront – returns the data contained in the first node, does not delete it  • RetrieveEnd – returns the data contained in the last node, does not delete it  • Retrieve(int index) – returns the data contained in node # index, does not delete  it, returns null if index is out of bounds or data does not exist  • PrintList – Loop through each node and print the contents of the Node  • Empty – Empty out the list, delete everything  • Length – How many elements are in the list  More methods private or public should be created as needed to facilitate the  functionality of the Interface methods.  If you feel your list needs more  functionality, feel free to create it.  As per usual, I have not made a perfect representation of the parameters you  might need, etc.  I have made suggestions where appropriate, but you might need  more depending on how you code things.  Node Class  • Constructor  • Destructor  • Getters & Setters   The node class should be fairly rudimentary.  Ideally, it should be templated so  you can store anything in it. Description:  You are going to create a silly Zombie Conga Line using your Linked List.  Each node is going to store a Zombie in it.  Zombies can be Red, Yellow, Green,  Blue, Magenta and Cyan.  Every turn you will randomly generate a Zombie object and an action.  You will  then perform that action using the Zombie object as the parameter for that  action.  NOTE – these actions are external to the Linked List.  They are accomplished by  calling Linked List methods.   Actions:  • Engine!  o This zombie becomes the first Zombie in the conga line  • Caboose!  o This zombie becomes the last zombie in the conga line  • Jump in the Line!  o This zombie joins the conga line at position X where X

Arun Shankar · Accepted Answer

LinkedList.cpp
#include 
#include 
using namespace std;
#include "LinkedList.h"
// Constructor
template 
LinkedList::LinkedList()
{
	head = nullptr;
	tail = nullptr;
  length = 0;
}
// Destructor
template 
LinkedList::~LinkedList()
{
	Empty();
}
// AddToFront(T data) – create a node containing T data and add it to the front of the list
template 
void LinkedList::AddToFront(T data)
{
  Node* newNode = new Node(data);
  if(head == nullptr)
    head = tail = newNode;
  else
  {
    newNode -> setNext(head);
    head = newNode;
  }
  ++length;
}
// AddToEnd(T data) – create a node containing T data and 
// add it to the end of the list
template 
void LinkedList::AddToEnd(T data)
{
  Node* newNode = new Node(data);
  if(head == nullptr)
    head = tail = newNode;
  else
  {
    tail -> setNext(newNode);
    tail = newNode;
  }
  ++length;
}
// AddAtIndex(T data, int index) – create a node 
// containing T data and add it to the
// list at index. The new node containing the data will 
// be the #index node in the
// list. Return boolean for success or failure (optional: 
// you could also return an
// integer with failure codes since this method can fail 
// multiple ways)
template 
bool LinkedList::AddAtIndex(T data, int index)
{
  if((index  length))
    return false;
  else if(index == 0)
    AddToFront(data);
  else if(index == length)
    AddToEnd(data);
  else
  {
    Node* newNode = new Node(data);
    Node* curr = head;
    Node* prev = nullptr;
    for(int i = 0; i  getNext();
    }
    prev -> setNext(newNode);
    newNode -> setNext(curr);
    ++length;
  }
  return true;
}
// RemoveFromFront() – Delete first item and return its 
// contents
template 
void LinkedList::RemoveFromFront()
{
  if(head == nullptr)
    return;
  else if(head == tail)
  {
    free(head);
    head = tail = nullptr;
  }
  else
  {
    Node* curr = head -> getNext();
    free(head);
    head = curr;
  }
  --length;
}
// RemoveFromEnd() – Delete last item and return its 
// contents
template 
void LinkedList::RemoveFromEnd()
{
  if(head == nullptr)
    return;
  else if(head == tail)
  {
    free(head);
    head = tail = nullptr;
  }
  else
  {
    Node* curr = head;
    while(tail != curr -> getNext())
      curr = curr -> getNext();
    free(tail);
    tail = curr;
    tail -> setNext(nullptr);
  }
  --length;
}
// ElementExists(T data) – Returns a T/F if element // exists in list
template 
bool LinkedList::ElementExists(T data)
{
  Node* curr = head;
  while(curr != nullptr)
  {
    if(data == curr -> getData())
      return true;
    curr = curr -> getNext();
  }
  return false;
}
// Find(T data) – Look for data in the list, return a 
// pointer to its node
template 
Node* LinkedList::

CSE 240 – Assignment 6 Points: 50 pts Topics: • C/C++ Syntax • Pointers • Functions • Dynamic Allocation of Memory • Data Structures: Linked Lists • Object Orientation Overall Specifications: You are...

Answer To: CSE 240 – Assignment 6 Points: 50 pts Topics: • C/C++ Syntax • Pointers • Functions • Dynamic...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment