• At the beginning of each semester, students get a course catalogue containing

Question

•   At the beginning of each semester, students get a course catalogue containing a list of course offerings for the semester. Information about each course, such as professor, department, and prerequisites will be included to help students make informed decisions.
•   The system will allow students to select four course offerings for the coming semester. In addition, each student will indicate two alternative choices in case the student cannot be assigned to a primary selection.
•   Course offerings will have a maximum of ten students and a minimum of three students. A course offering with fewer than three students will be cancelled. Once the registration process is completed for a student, the registration system sends information to the billing system so the student can be billed.
•   Professors must be able to access the online system to indicate which courses they will be teaching. They will also need to see which students signed up for their course offerings.
•   For each semester, there is a period of time that students can change their schedule. Students must be able to access the system during this time to add or drop courses.
Please read the simple scenario carefully for the project, and answer the following questions:

Q1: Using Microsoft Project 2007/2010 tool, draw Gantt Chart for “Course Registration Project” showing the task name and the duration of each task (Work Breakdown Structure (WBS))?      

Q2: Using a mind mapping software create a mind map of a SWOT analysis for the “Course Registration Project”, including at least two strengths, weaknesses, opportunities and threats.

Q3: List the key outputs of each process group in the “Course Registration Project”.      

Explanation / Answer

typedef int SortListItemType;

class SortListClass
creator
~SortListClass(); // destructor

SortListClass(const SortListClass& existingList); // copy builder
SortListClass& operator=(const SortListClass& rhs); // assignment operator

// list operations:
bool isEmpty() const;
int getLength() const;

// strategies come true if prospering, false otherwise
// bool insert(int position, SortListItemType& newItem);
bool insert(SortListItemType& newItem);

bool remove(int position);
  
bool retrieve(int position, SortListItemType& dataItem) const;
void PrintsortList();
int find(SortListItemType& dataItem) const;
void SortListClass::deleteItem(int deleteItem);
void DestoryNode();
private:
struct SortListNode
;

int size; // range of things in list
  

SortListNode *head; // pointer to coupled list of things
SortListNode *last;
SortListNode *ptrTo(int position) const;
// Returns a pointer to the node at position (1 .. k) in list
};

//*******************************************************
// Implementation file LabListP.cpp for the ADT list.
// Pointer-based implementation.
//*******************************************************
#include "SortLabListP.h" // header file
#include <cstddef> // for NULL
#include <cassert> // for assert()
#include <iostream>
using namespace std;
SortListClass::SortListClass()
: size(0), head(nullptr), last(nullptr)

SortListClass::~SortListClass() // Destructor
whereas (!isEmpty())
one
}
}

bool SortListClass::isEmpty() const
{
come bool(size == 0);
}

int SortListClass::getLength() const
{
come size;
}

/*// assignment operator: create DEEP copy
SortListClass& SortListClass::operator=(const SortListClass& rhs)
almost like Copy builder, except
// - Avoid self-assignments like “X = X;”
// - Delete existing this-instance content before
// creating this-instance a duplicate of the rhs instance
  
return(*this);
}
*/

// Copy Constructor: create DEEP copy
SortListClass::SortListClass(const SortListClass& existingList): size(existingList.size)
1st node
head = new SortListNode;
assert(head != NULL); // check allocation

head->item = existingList.head->item;

// copy remainder of list
SortListNode *newPtr = head; // new list pointer

// newPtr points to last node in new list
// origPtr points to nodes in original list
for (SortListNode *origPtr = existingList.head->next;
origPtr != NULL;
origPtr = origPtr->next)
to finish of list
assert(newPtr->next != NULL);
newPtr = newPtr->next;

newPtr->item = origPtr->item; // copy the info
newPtr->next = NULL;
}
}
//return(*this);
}

// ----------------------------------------------------------------------
// Locates a given node during a coupled list.
// Precondition: position is that the range of the required node.
// Postcondition: Returns a pointer to the required node.
// If position < one or position > size (the range of nodes within the list),
// returns NULL.
// ----------------------------------------------------------------------

SortListClass::SortListNode *SortListClass::ptrTo(int position) const
{
if ((position < 1) || (position > size))
come NULL;

else // count from the start of the list
{
  
SortListNode *cur = head;

for (int skip = 1; skip < position; ++skip)
cur = cur->next;

come cur;
}
}

bool SortListClass::retrieve(int position, SortListItemType& dataItem) const
knowledge in node
SortListNode *cur = ptrTo(position);

dataItem = cur->item;
}

return(success);
}

bool SortListClass::insert(SortListItemType& newItem)

// produce new node and place newItem in it
SortListNode *newPtr = new SortListNode; newPtr->item = newItem;
newPtr->next = cur;
if (prev == NULL) head = newPtr;
// insert new node to right of previous node
else prev->next = newPtr;
size++;
return(0);
}

int SortListClass::find(SortListItemType& dt) const
whereas (cur != NULL)
{
if (cur->item == dt)
come cnt;
else

}
come false;
}

bool SortListClass::remove(int position)
the primary node from the list
cur = head; // save pointer to node
head = head->next;
}
else
when the node
// to that prev points
cur = prev->next; // save pointer to node
prev->next = cur->next;
}

// come node to system
cur->next = NULL; // safety - take away node from list
delete cur;
cur = NULL; // safety
}
return(success);
}

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

//LabListMain.cpp
// LabListRandom
// CSC 2430 work Assignment
// Written by:
// Date:

#include <iostream>
#include <iomanip>
#include <cstddef>
#include <limits>
using namespace std;

#include "SortLabListP.h"

void printListClass(char listname[], const SortListClass& lst)
the concerns RANGE; // turn out next random range worth
listbyposition.insert( val); // place val into list at position i
}

// Output initial knowledge list
printListClass("listbyposition", listbyposition);

system("pause");
return(0);
}

Related Questions

Navigate

• Browse (All)
• Browse #
• Subjects

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