void HashTable::print(void) {
Node* navigator = m_head;
while (navigator != 0) {
cout << navigator->getValue() << endl;
navigator = navigator->getNext();
}
}
/**********************************************************************
* display whole link list
***********************************************************************/
void List::display() const
{
cout << "----DISPLAY----" << endl;
Node* cur = firstNode;
for (int i = 0; cur; ++i)
{
cout << i << " = i " << cur->getData() << "-> " << cur->getNext() << endl;
cur = cur->getNext();
}
cout << "~~~NULL" << endl;
cout << numItems << endl;
}
void Q::push(Sortable *s)
{
if(!m_start) // Empty list
{
m_start = new Node(s);
m_start->setNext(m_start);
m_start->setPrev(m_start);
}
else
{
Node *new_node = new Node(s);
Node *cur = m_start;
while( cur->getData()->compareTo(s) <= 0 )
{
cur = cur->getNext();
if(cur == m_start)
break; // Looped around
}
new_node->setNext(cur);
new_node->setPrev(cur->getPrev());
cur->getPrev()->setNext(new_node);
cur->setPrev(new_node);
// We inserted before the first node, so update m_start
if(cur == m_start && m_start->getData()->compareTo(s) > 0)
m_start = new_node;
}
}
void List<T>::insertBefore(int target, const T& data) {
if (!hasFirst()) {
return;
}
Node<T>* currentNode = getFirst();
Node<T>* newNode = new Node<T>(data);
for (int i = 0; i <= target; i++) {
if (i == target) {
if (currentNode->hasPrev()) {
currentNode->getPrev()->setNext(newNode);
newNode->setPrev(currentNode->getPrev());
}
newNode->setNext(currentNode);
currentNode->setPrev(newNode);
return;
}
if (!currentNode->hasNext()) {
return;
}
currentNode = currentNode->getNext();
}
delete currentNode;
}
bool HashTable::findWord(string word) {
Node* navigator = m_head;
string dictWord;
while (navigator != 0) {
dictWord = navigator->getValue();
if (dictWord == word) {
return true;
}
//check for omissions
if (dictWord.length() <= word.length() + 1 || dictWord.length() <= word.length() - 1) {
int count = 0;
//check for misplaced letter
for (int i = 0; i < dictWord.length() && i < word.length(); i++) {
if (dictWord[i] == word[i]) {
count++;
}
}
if (count >= (word.length() - 1)) {
if (m_suggestions.size() < 10) {
m_suggestions.push_back(dictWord);
}
}
}
navigator = navigator->getNext();
}
return false;
}
LinkedBag<ItemType>::LinkedBag(const LinkedBag<ItemType>& aBag)
{
itemCount = aBag->itemCount;
Node<ItemType>* origChainPtr = aBag->headPtr; // Points to nodes in original chain
if (origChainPtr == NULL)
headPtr = NULL; // Original bag is empty; so is copy
else
{
// Copy first node
headPtr = new Node<ItemType>();
headPtr->setItem(origChainPtr->getItem());
// Copy remaining nodes
Node<ItemType>* newChainPtr = headPtr; // Last-node pointer
while (origChainPtr != NULL)
{
origChainPtr = origChainPtr ->getNext(); // Advance pointer
// Get next item from original chain
ItemType nextItem = origChainPtr->getItem();
// Create a new node containing the next item
Node<ItemType>* newNodePtr = new Node<ItemType>(nextItem);
// Link new node to end of new chain
newChainPtr->setNext(newNodePtr);
// Advance pointer to new last node
newChainPtr = newChainPtr->getNext();
} // end while
newChainPtr->setNext(NULL); // Flag end of new chain
} // end if
} // end copy constructor
void ContactManager::print(){
cout << "Print Fun.\n";
Node<Contact>* nPtr = contacts.getHead() ;
int c = 0 ;
while( nPtr != NULL)
{
// cout << "here";
//string cn = nPtr->getData().getName() ;
cout << nPtr->getData() << endl;
//cout << cn << endl;
/************************* my edit 34an ygeeb 2li gwa kol contact **************************************/
/*Node<string>* first = nPtr->getData().phone_numbers.getHead() ;
while( first != NULL )
{
cout << first->getData() << " " ;
first = first->getNext() ;
}
cout << "\n-----\n";*/
nPtr = nPtr->getNext() ;
c++ ;
}
cout << " - Unique Names : " << c ;
}
//removes the node at the specified index
//if the index is not in the list or there are no items in the list it returns nullptr
//otherwise it returns the node that was removed
Node<Type>* remove(int index){
if(size == 0){
ioc << cat_error << vrb_quiet << "List is empty" << io_end;
return nullptr;
}
else if(index < 0 || index > size - 1)
{
ioc << cat_error << vrb_quiet << "Index out of bounds" << io_end;
return nullptr;
}
else if(index == 0)
{
Node<Type>* prev = head;
head = head -> getNext();
size--;
return prev;
}
else{
Node<Type>* prev = head;
Node<Type>* curr = head;
for(int i = 0; i < index; i++, prev = curr, curr = curr -> getNext());
prev->setNext(curr->getNext());
size--;
return curr;
}
}
bool LinkedList<T>::search(T value) const
{
Node<T>* temp = m_front;
bool isFound = false;
if(isEmpty())//if it's empty juts return false
{
return(false);
}
while(temp!=nullptr) //this condition loops until the last node
{
if(temp->getValue()==value)
{
isFound=true;//return true if it matches the value
break;//and break the loop when you find it
}
else
{
temp=temp->getNext();//if you don't find it, move on to the next element
}
}
return(isFound);
}
int main (int argc, char** argv)
{
using namespace std;
int c = 1;
// create a new list made by 1,2,3
Node start (c);
Node *second=new Node(2);//new node to add
start.append(second);
Node *third=new Node(3);//new node to add
start.append(third);
//start.print ();
//test on getPrevious
//returns a pointer to the second node that stores value 2
Node *prec;
prec=third->getPrevious() ;
//test on getNext
//returns a pointer to the second node that stores value 2
Node *succ;
succ=start.getNext() ;
//I check the value stored in the Node pointers to verify that getNext and getPrevious points to the correct node
fprintf(stdout,"%d and %d",prec->getData(),succ->getData());
return 0;
}
TYPE* toArray(TYPE* arr,int cur,Node* root){
if(root==NULL){
return NULL;
}
arr[cur]=root->getKey();
return toArray(arr,cur+1,root->getNext());
}
bool LinkedList::insert(int newPosition, const ItemType& newEntry)
{
bool ableToInsert = (newPosition >= 1) && (newPosition <= itemCount + 1);
if (ableToInsert)
{
// Create a new node containing the new entry
Node* newNodePtr = new Node(newEntry);
// Attach new node to chain
if (newPosition == 1)
{
// Insert new node at beginning of chain
newNodePtr->setNext(headPtr);
headPtr = newNodePtr;
}
else
{
// Find node that will be before new node
Node* prevPtr = getNodeAt(newPosition - 1);
// Insert new node after node to which prevPtr points
newNodePtr->setNext(prevPtr->getNext());
prevPtr->setNext(newNodePtr);
}
itemCount++; // Increase count of entries
}
return ableToInsert;
} // end insert
void SinglyLinkedList<ItemType>::add(const ItemType &newItem)
{
Node<ItemType> *newNodePtr = new Node<ItemType>();
Node<ItemType> *pos = headPtr;
Node<ItemType> *prevPtr = 0;
while (pos != 0 && pos->getItem() != 0)
{
prevPtr = pos;
pos = pos->getNext();
}
newNodePtr->setNext(pos);
if (prevPtr != 0)
{
prevPtr->setNext(newNodePtr);
}
else
{
headPtr = newNodePtr;
}
itemCount++;
}
template <class ItemType> bool LinkedList <ItemType>::remove(int position)
{
// remove an item from an existing list. if successful list will have
// count - 1 items. Deleted position can be anywhere from 1 to count
// 1 corresponds to the beginning of the list, count corresponds to
// the end of the list, and anything in between will be at the appropriate
// location in the middle of the list
bool result;
if ((position < 1) || (position > count))
{
result = false;
}
else {
Node<ItemType>* curPtr = nullptr;
if (position == 1)
{
// Remove the first node in the chain
curPtr = headPtr;
headPtr = headPtr->getNext();
}
else
{
// Find node that is before the one to delete
Node<ItemType>* prevPtr = getNodeAt(position - 1);
// Point to node to delete
curPtr = prevPtr->getNext();
// Disconnect indicated node from chain by connecting the
// prior node with the one after
prevPtr->setNext(curPtr->getNext());
}
// Return node to system
curPtr->setNext(nullptr);
delete curPtr;
curPtr = nullptr;
count--;
result = true;
}
return result;
}
LinkedBag<ItemType> LinkedBag<ItemType>::bagUnion(const LinkedBag& input) const {
// make a new LinkedBag that will hold the union
// put input values into theUnion with copy constructor
LinkedBag<ItemType> theUnion = LinkedBag(input);
// put caller values into theUnion
theUnion.itemCount = itemCount+input.itemCount;
Node<ItemType>* origChainPtr = headPtr; // Points to nodes in original chain
if (origChainPtr == nullptr)
//theUnion->next = nullptr; // caller bag is empty
// do nothing
else
{
// Copy first node
Node<ItemType>* newChainPtr = theUnion.
***** STOPPED HERE
headPtr = new Node<ItemType>();
headPtr->setItem(origChainPtr->getItem());
// Copy remaining nodes
Node<ItemType>* newChainPtr = headPtr; // Points to last node in new chain
origChainPtr = origChainPtr->getNext(); // Advance original-chain pointer
while (origChainPtr != nullptr) // origChainPtr is used as our counting pointer to traverse
// the old chain
{
// Get next item from original chain
ItemType nextItem = origChainPtr->getItem();
// Create a new node containing the next item
Node<ItemType>* newNodePtr = new Node<ItemType>(nextItem);
// Link new node to end of new chain
newChainPtr->setNext(newNodePtr);
// Advance pointer to new last node
newChainPtr = newChainPtr->getNext();
// Advance original-chain pointer
origChainPtr = origChainPtr->getNext();
} // end while
newChainPtr->setNext(nullptr); // Flag end of chain
} // end if
} // end copy constructor
void LinkedList<Item>::insertAt(const int& location, const Item& _key, const Item& _value) {
if (location > size)
throw std::runtime_error("Parameter 'location: int' in function LinkedList<Item>::insertAt() is out of range.");
else {
Node<Item>* traverser = head;
for (int i = 0; i < location; i++)
traverser = traverser->getNext();
if (head == NULL) {
/* This is the case of when the list is empty. */
head = new Node<Item>(_key, _value);
} else if (location == size) {
/* This is the case where we're inserting at the end of the list when it's not empty. */
/* I know the below loop is a pretty inefficient thing to do.
* But since efficiency is not the matter right now, so be it.
* Hackin' together a solution!
*/
traverser = head;
for (int i = 0; i < location-1; i++)
traverser = traverser->getNext();
Node<Item>* newNode = new Node<Item>(_key, _value);
traverser->setNext(newNode);
} else if (location == 0) {
/* This is the case of head insertion when the list isn't empty. */
Node<Item>* newNode = new Node<Item>(_key, _value);
newNode->setNext(head);
head = newNode;
} else {
/* This is the case where we're inserting between 2 Nodes. */
Node<Item>* beforeTraverser = head;
for (int i = 0; i < location - 1; i++)
beforeTraverser = beforeTraverser->getNext();
Node<Item>* afterTraverser = traverser;
traverser = new Node<Item>(_key, _value);
traverser->setNext(afterTraverser);
beforeTraverser->setNext(traverser);
}
size++;
}
}
void DLList<T>::insert(T item, int pos)
{
// Check pos to see if it is negative
if (pos < 0)
{
cout << "Invalid position. List cannot have negative index.";
exit(1);
}
else
{
Node<T>* trav = firstNode; // traversal pointer
Node<T>* temp = new Node<T>; //create node and fill with item
temp->setData(item);
if (pos > numItems) // if pos > list size, set pos for tail insert
pos = numItems;
if (pos == 0) // head insert
{
if (firstNode != NULL) // make sure list not empty
{
temp->setNext(firstNode);
firstNode->setPrevious(temp);
}
firstNode = temp;
}
else if (pos == numItems) // tail insert
{
for (int i = 0; i < pos - 1; i++)
trav = trav->getNext();
trav->setNext(temp);
temp->setPrevious(trav);
}
else //any inserts in between nodes
{
for (int i = 0; i < pos - 1; i++)
trav = trav->getNext();
temp->setNext(trav->getNext());
temp->setPrevious(trav);
trav->setNext(temp);
temp->getNext()->setPrevious(temp);
}
numItems++;
}
}
// Append new node to the end of the list
void appendToEnd(T d)
{
Node<T> *tmp = new Node<T>(d);
if (next == nullptr)
{
next = tmp;
return;
}
Node<T> *n = next;
while (n->getNext() != nullptr)
{
n = n->getNext();
}
n->setNext(tmp);
}
void traverse(){
Node<T>* trav = head;
while(trav != NULL){
std::cout << trav->getData() << std::endl;
trav = trav->getNext();
}
}
/**
* Aumenta la edad de todos en 1
*/
void Population::EverybodyBirthday(){
Node<Entity*>* tmp = _individuos->getHead();
for(int i = 0 ; i < (_individuos->getLength()); i++){
tmp->getData()->Birthday();
tmp = tmp->getNext();
}
return;
}
void Stack::display(){
Node * ptr = head;
while(ptr){
cout << ptr->getData() << ' ';
ptr = ptr->getNext();
}
cout << endl;
}
bool detectCircularList(Node* head) {
Node* fastPtr = head;
Node* slowPtr = head;
while(fastPtr != nullptr && slowPtr != nullptr) {
fastPtr = fastPtr->getNext();
if(fastPtr == nullptr) break;
if(fastPtr == slowPtr) return true;
fastPtr = fastPtr->getNext();
if(fastPtr == nullptr) break;
if(fastPtr == slowPtr) return true;
slowPtr = slowPtr->getNext();
}
return false;
}
void size()
{
if(head==0)
cout<<0<<endl;
else
{
int cnt=1;
Node *temp;
temp=head;
while(temp->getNext()!=0)
{
cnt++;
temp=temp->getNext();
}
cout<<cnt<<endl;
}
}
/**
* @brief print
* Prints the content of the linked list
*/
void ShapeList::print(){
Node *current = _pHead;
while (current != 0){ //->getNext() != 0) {
Shape* s = current->getValue();
s->print();
current = current->getNext();
}
}
~List(){
Node *head = this->root;
while(head){
Node *tmp = head->getNext();
delete head;
head = tmp;
}
}
vector<Customer*> LinkedList::getAll()
{
vector<Customer*> customers;
if(isEmpty())
{
return customers;
}
Node* curr = this->head;
while(curr->getNext() != NULL)
{
curr = curr->getNext();
customers.push_back(curr->getData());
}
return customers;
}
void LinkedList::addToEnd(Data toAdd){
clock_t start = clock();
//set to start if there is no elements in the list
if (theStart == nullptr){
theStart = new Node(&toAdd, nullptr);
}
else {
Node* current = theStart;
//read through list to get to end
while (current->getNext() != nullptr){
current = current->getNext();
}
current->setNext(new Node(&toAdd, nullptr));
}
currSize++;
ticks += clock() - start;
}
void List::remove(Node *element)
{
Node *p = head, *q = NULL;
while ((p != element) && (p != NULL))
{
q = p;
p = p->getNext();
}
if (p == NULL)
return;
if (p == tail)
tail = q;
if (p == head)
head = p->getNext();
if (q != NULL)
q->setNext(p->getNext());
}
//Input: index of person you want to get
//Output: string of the person at that index
//Purpose: to get the a single person in the list
std:: string Queue:: get(int index){
Node* next = first;
for ( int i = 0; i < index; i++){
next = next->getNext();
}
std:: string info = next->getName() + " ID Number: " + std::to_string( next->getIdNumber() );
return info;
}
//Destructor
//Input: nothing
//Output nothing
//Purpose: code that needs to be destroyed before queue is
Queue:: ~Queue(){
if (first == nullptr) {
return;
}
if (first->getNext() == nullptr) {
return;
}
Node* next = first->getNext();
delete first;
for (int i = 1; i < size; i++) {
if (next->getNext() == nullptr) {
return;
}
next = next->getNext();
delete next;
}
}