void LinkedList::insert(int pos, int x){
//inserts a new node with value x after pos-th node
assert(pos <= this->getSize());
if(pos == 0){
if(this->getSize() == 0) this->addNode(x);
else{
Node *tmp = new Node(x);
head->setPrev(tmp);
tmp->setNext(head);
head = tmp;
}
this->modifySize(this->getSize() + 1);
return;
}
Node *cur = head;
int counter = 1;
while(counter < pos){
cur = cur->getNext();
++counter;
}
Node *tmp = new Node(x);
tmp->setNext(cur->getNext());
cur->getNext()->setPrev(tmp);
tmp->setPrev(cur);
cur->setNext(tmp);
this->modifySize(this->getSize() + 1);
}
Node* insert(Node* head, int data){
Node* curr = head;
Node* newNode = new Node(data);
//handle head case
if(newNode->getData() <= head->getData()){
//newNode set to head node
newNode->setNext(head);
//head now newNode
head = newNode;
}else{
//Find first node > newnode
while(newNode->getData() > curr->getData()){
//iterate list
curr = curr->getNext();
}
//set newNode to next
newNode->setNext(curr->getNext());
//set node before newnode to newnode
curr->setNext(newNode);
}
return head;
}
bool LinkedList<ItemType>::insert(int newPosition, const ItemType& newEntry)
{
bool ableToInsert = (newPosition >= 1) && (newPosition <= itemCount + 1);
if (ableToInsert)
{
// Create a new node containing the new entry
Node<ItemType>* newNodePtr = new Node<ItemType>(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<ItemType>* prevPtr = getNodeAt(newPosition - 1);
// Insert new node after node to which prevPtr points
newNodePtr->setNext(prevPtr->getNext());
prevPtr->setNext(newNodePtr);
} // end if
itemCount++; // Increase count of entries
} // end if
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++;
}
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 LinkedList<T>::deleteAt(int index) {
if (index == 0) { //just delete the front
popFront();
}
else if (index == length-1) { //just delete the back
popBack();
}
else if (index < 0 || index >= length) { //index is not valid
std::cout << "Invalid index" << endl;
return;
}
else {
Node<T>* currentAtIndex = first;
for (int i = 0; i < index; i++) { //find the desired node to be deleted
currentAtIndex = currentAtIndex->getNext();
}
Node<T>* before = first;
while (before->getNext() != currentAtIndex) { //find the node before the one to be deleted
before = before->getNext();
}
before->setNext(currentAtIndex->getNext());
currentAtIndex->setNext(nullptr);
length--;
}
}
void Hash::addBack(int value)
{
if(isEmpty())
{
m_front = new Node();
m_front->setValue(value);
m_front->setNext(nullptr);
}//if - Hash is empty therefore, create first node
else
{
Node* newNode = new Node();
newNode->setValue(value);
newNode->setNext(nullptr);
Node* temp = m_front;
if((temp->getNext()) != nullptr)
{
for(temp=m_front;(temp->getNext())!=nullptr;temp=temp->getNext());
temp->setNext(newNode);
}//if -
else
{
temp->setNext(newNode);
}//else -
}//else - Hash has elements
m_size++;
}//addBack - add node to the back of the Hash
bool LinkedList<ItemType>::remove(int position)
{
bool ableToRemove = (position >= 1) && (position <= itemCount);
if (ableToRemove)
{
Node<ItemType>* curPtr = nullptr;
if (position == 1)
{
// Remove the first node in the chain
curPtr = headPtr; // Save pointer to node
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());
} // end if
// Return node to system
curPtr->setNext(nullptr);
delete curPtr;
curPtr = nullptr;
itemCount--; // Decrease count of entries
} // end if
return ableToRemove;
} // end remove
bool LinkedList::remove(int customerNumber)
{
if(isEmpty())
return false;
Node* curr = this->head->getNext();
Node* prev = this->head;
for(int i = 0; i < this->size; i++)
{
if(curr->getData()->getCustNumber() == customerNumber)
{
if(i == this->size-1)
{
prev->setNext(NULL);
}
else
{
prev->setNext(curr->getNext());
}
delete curr->getData();
delete curr;
this->size = this->size - 1;
return true;
}//end if
prev = curr;
curr = curr->getNext();
}//end loop
return false;
}
void List<T>::insertAfter(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) {
newNode->setPrev(currentNode);
if (currentNode->hasNext()) {
newNode->setNext(currentNode->getNext());
currentNode->getNext()->setPrev(newNode);
}
currentNode->setNext(newNode);
return;
}
if (!currentNode->hasNext()) {
return;
}
currentNode = currentNode->getNext();
}
delete currentNode;
}
Node<T>* LinkedList<T>:: addToList( T &item ){
// cout << "HERE " ;
Node<T>* newNode = new Node<T> ( item , NULL );
Node<T>* nPtr = head , *pPtr = head ;
if(head == NULL ){
head = newNode ;
head->setNext(NULL);
return newNode ;
}
// cout << ":O \n" ;
T c = nPtr->getData() ;
bool b = 0 ;
while( nPtr != NULL && c < item ){
b = 1 ;
pPtr = nPtr ;
nPtr = nPtr->getNext() ;
if( nPtr == NULL )
break ;
c = nPtr->getData() ;
}
if( c == item )
return nPtr ;
if( pPtr == head && nPtr != head ){
newNode->setNext( nPtr ) ;
pPtr->setNext( newNode ) ;
}
else if( /*( pPtr == head && nPtr == head && nPtr->getNext() != NULL ) ||*/ b == 0 ){
newNode->setNext( nPtr ) ;
head = newNode ; //pPtr->setNext( newNode ) ;
}
else if( pPtr->getNext() != NULL ){
newNode->setNext( pPtr->getNext() ) ;
pPtr->setNext( newNode ) ;
}
else{
pPtr->setNext( newNode ) ;
newNode->setNext( NULL ) ;
}
return newNode ;
}
void insert(LinkedList* lst, string l, int p) {
Node* newNode = new Node(l,p);
Node* walker = lst->get_listHead();
while (walker->getNext() != NULL && newNode->getProb() > walker->getNext()->getProb()) {
walker = walker->getNext();
}
newNode->setNext(walker->getNext());
walker->setNext(newNode);
}
/*Inserting a value in front of the head node.*/
void LinkedList::insert_front(int data){
// creating a new node.
Node *newNode = new Node();
newNode->setData(data);
newNode->setNext(NULL);
newNode->setNext(head);
head = newNode;
}
bool LinkedList<ItemType>::remove(int position)
{
bool ableToRemove = (position >= 1) && (position <= itemCount);
if (ableToRemove)
{
// point at the node to be removed
Node<ItemType>* curPtr = getNodeAt(position);
// case 1: to remove the only node on a list of length 1
if ((position == 1) && (itemCount == 1)) {
headPtr = nullptr;
tailPtr = nullptr;
}
// case 2: to remove the first node in list of length > 1
else if ((position == 1) && (itemCount > 1))
{
Node<ItemType>* nextPtr = getNodeAt(position + 1);
nextPtr->setPrev(nullptr);
headPtr = nextPtr;
nextPtr = nullptr;
}
// case 3: to remove the last node in list of length > 1
else if ((position == itemCount) && (itemCount > 1))
{
Node<ItemType>* prevPtr = getNodeAt(position - 1);
prevPtr->setNext(nullptr);
tailPtr = prevPtr;
prevPtr = nullptr;
}
// case 4: to remove a node in the middle of list of length > 1
else if ((1 < position) && (position < itemCount) && (1 < itemCount) )
{
// Create node pointers to hold our place in the chain
Node<ItemType>* prevPtr = getNodeAt(position - 1);
Node<ItemType>* nextPtr = getNodeAt(position + 1);
// Disconnect indicated node from chain by connecting the
// previous node with the next node
prevPtr->setNext(nextPtr);
nextPtr->setPrev(prevPtr);
} // end if
// Return node to system
curPtr->setNext(nullptr);
curPtr->setPrev(nullptr);
delete curPtr;
curPtr = nullptr;
itemCount--; // Decrease count of entries
} // end if
return ableToRemove;
} // end remove
void newInsert(LinkedList* btree,string l, int p) {
Node* newNode = new Node(l,p);
newNode->setLeft(btree->get_listHead()->getNext());
newNode->setRight(btree->get_listHead()->getNext()->getNext());
btree->get_listHead()->setNext(btree->get_listHead()->getNext()->getNext()->getNext());
Node* walker = btree->get_listHead();
while (walker->getNext() != NULL && newNode->getProb() > walker->getNext()->getProb()) {
walker = walker->getNext();
}
newNode->setNext(walker->getNext());
walker->setNext(newNode);
}
/**********************************************************************
* remove item at the specified position
***********************************************************************/
void List::remove(int pos)
{
Node* cur = firstNode;
Node* tmp = NULL;
int i =0;
if (pos >= numItems)
{
pos = numItems;
}
if (pos < 0)
{
pos = 0;
}
// head insert
if (pos <= 0)
{
tmp = firstNode;
firstNode = firstNode->getNext();
delete tmp;
}
// after insert
else
{
for (i = 0; i < pos - 1; ++i)
{
cur = cur->getNext();
}
tmp = cur->getNext();
if (cur->getNext() != NULL)
{
cur->setNext( cur->getNext()->getNext() );
}
else
{
cur->setNext(NULL);
}
delete tmp;
}
numItems--;
}
int main()
{
stringstream ss;
int item;
string input;
// get numbers to be sorted
cout << "Enter numbers to be sorted: ";
getline(cin, input);
ss << input;
// add items to linked list
Node<int> *head = nullptr; // points to head of list
while(ss >> item)
{
Node<int> *ptr = new Node<int>(item);
ptr->setNext(head);
head = ptr;
}
// sort list
head->mergeSort(head);
// print linked list
cout << "Sorted numbers: ";
for(Node<int> *curPtr = head;
curPtr != nullptr;
curPtr = curPtr->getNext())
cout << curPtr->getItem() << " ";
// set all pointers to null in linked list
Node<int>* curPtr = head->getNext();
while(curPtr != nullptr)
{
head->setNext(nullptr);
head = curPtr;
curPtr = curPtr->getNext();
}
delete curPtr;
curPtr = nullptr;
delete head;
head = nullptr;
ss.clear();
return 0;
}
static Node<T>* partitionList(Node<T> *head, int x)
{
Node<T> *lwiter = nullptr;
Node<T> *n = head;
Node<T> *uphead = head;
Node<T> *upiter = nullptr;
while (n != nullptr)
{
if (n->getData() <= x)
{
// Add node to lower list.
if (lwiter == nullptr)
{
lwiter = n;
head = lwiter;
}
else
{
lwiter->setNext(n);
lwiter = lwiter->getNext();
}
}
else
{
// Upper Parition
if (upiter == nullptr)
{
upiter = n;
uphead = upiter;
}
else
{
upiter->setNext(n);
upiter = upiter->getNext();
}
}
n = n->getNext();
if (lwiter != nullptr) lwiter->setNext(nullptr);
if (upiter != nullptr) upiter->setNext(nullptr);
}
// Connect the lower and upper paritions
lwiter->setNext(uphead);
return head;
}
void List::addTolist(int data){
Node* newnode = new Node();
newnode->setData(data);
newnode->setNext(NULL);
if(head == NULL){
head = newnode;
curr = head;
}
else{
curr->setNext(newnode);
curr = newnode;
}
}
void List::insertByIndex(double inData, uint index)
{
if (index == 0)
{
pushFront(inData);
}
else if (index == _count)
{
pushBack(inData);
}
else
{
Node* element = elementByIndex(index);
if (element != NULL)
{
_count++;
Node* newElement = new Node(inData);
newElement->setNext(element);
newElement->setPrevious(element->getPrevious());
element->getPrevious()->setNext(newElement);
element->setPrevious(newElement);
}
}
}
void Stack<T>::push(const T& newEntry){
Node<T>* n = new Node<T>();
n->setValue(newEntry);
m_size++;
n->setNext(m_top);
m_top = n;
}
void LinkedList::insert(int val)
{
if(m_head == nullptr)
{
m_head = new Node(val);
}
else
{
if(Find(val) == nullptr)
{
Node* tempPtr = m_head;
Node* newNode = new Node(val);
while(tempPtr->getNext() != nullptr)
{
tempPtr = tempPtr->getNext();
}
tempPtr->setNext(newNode);
}
else
{
std::cout<<"The number already exists"<<std::endl;
}
}
m_size++;
}
bool LinkedList<T>::removeBack()
{
Node<T>* lastNode = nullptr;
Node<T>* secondToLast = nullptr;
bool isRemoved = false;
if(m_size==1)
{
delete(m_front);
m_front=nullptr;
m_size=0;
isRemoved=true;
}
else if (m_size>=2)
{
secondToLast=m_front;
lastNode=secondToLast->getNext();
//iterate to last 2 nodes
while(lastNode->getNext()!=nullptr)
{
secondToLast=secondToLast->getNext();
lastNode=lastNode->getNext();
}
delete(lastNode);
secondToLast->setNext(nullptr);
isRemoved=true;
m_size--;
}
return(isRemoved);
}
DLList<T>& DLList<T>::operator = (const DLList<T> &rightSide)
{
if (this == &rightSide)
return *this;
else
{
numItems = rightSide.numItems;
this->~DLList<T>(); // delete old list
if (rightSide.firstNode == NULL) // if rightSide is empty, done here.
return *this;
else // traverse rightSide and copy its Nodes to calling object.
{
Node<T>* rhs = rightSide.firstNode;
Node<T>* trav = new Node<T>;
trav->setData(rhs->getData()); // assign first node data
firstNode = trav; // firstNode is now set. Doesnt change after this
rhs = rhs->getNext();
while (rhs != NULL)
{
trav->setNext(new Node<T>);
trav->getNext()->setPrevious(trav);
trav = trav->getNext();
trav->setData(rhs->getData());
rhs = rhs->getNext();
}
}
return *this;
}
}
T *Queue<T>::dequeueW()
{
Node<T> *n;
T *ret;
{
std::unique_lock<std::mutex> u(m);
Node<T> **th = &head;
n = head->getNext();
if (n == nullptr)
{
dataAvi.wait(u, [th, &n]() {
n = (*th)->getNext();
return n != nullptr;
});
}
resetHead(n);
#ifdef USE_CACHE_TOREUSE_NODES
ret = n->getVal();
n->setNext(cStart);
cStart = n;
#endif // USE_CACHE_TOREUSE_NODES
}
#ifndef USE_CACHE_TOREUSE_NODES
ret = n->getVal();
delete n;
#endif // !USE_CACHE_TOREUSE_NODES
return ret;
}
bool LinkedList<T>::removeBack()
{
Node<T>* lastNode = nullptr;
Node<T>* secondintoLast = nullptr;
bool isRemoved = false;
if(!isEmpty())
{
if(m_size == 1){
delete m_front;
m_front = nullptr;
}else{
Node<T>* traverse = m_front;
Node<T>* temp = traverse;
for(int i=1; i<=(size()-1); i++){
traverse = temp;
temp = temp->getNext();
}
delete temp;
traverse->setNext(nullptr);
}
m_size--;
isRemoved = true;
}
return(isRemoved);
}
DLList<T>::DLList(const DLList<T> &listToCopy)
{
numItems = listToCopy.numItems;
//if empty list
if (listToCopy.firstNode == NULL)
{
firstNode = NULL;
return;
}
Node<T>* rhs = listToCopy.firstNode;
Node<T>* trav = new Node<T>;
trav->setData(rhs->getData());
firstNode = trav;
rhs = rhs->getNext();
while (rhs != NULL)
{
trav->setNext(new Node<T>);
trav->getNext()->setPrevious(trav);
trav = trav->getNext();
trav->setData(rhs->getData());
rhs = rhs->getNext();
}
}
int main() {
Node* n = new Node(27);
cout << n->getValue() << endl;
Node* n2 = new Node(39);
n->setNext(*n2);
cout << n->getNext() << endl;
//Node* address = n->getNext();
//cout << address->getValue() << endl;
cout << (n->getNext())->getValue() << endl;
//cout << "Size is " << n ->size() << endl;
//cout << "Is empty: " <<n->isEmpty() << endl;
/*for (int i=0; i<10; i++) {
//cout << i << endl;
q->enqueue(i);
}
cout << "Size is " << q->size() << endl;
cout << "Is empty: " <<q->isEmpty() << endl;
for (int i=0; i<10; ++i) {
cout << q->dequeue() << endl;
}
cout << "Is empty: " <<q->isEmpty() << endl;
delete q;
//next line is 'segmentation fault, proves it's deleted
//cout << "Size is " << q->size() << endl;
*/
return 0;
}
void SkewHeap::levelOrder(Node* root)
{
int curLevel=1;
Queue* myQueue = new Queue();
Node* temp;
if(root==nullptr)
{
return;
}
root->m_level=0;
myQueue->enqueue(root);
while(!(myQueue->isEmpty()))
{
temp=myQueue->dequeue();
temp->setNext(nullptr);
if(temp->m_level==curLevel)
{
std::cout << "\n";
curLevel++;
}
std::cout << temp->getValue() << " ";
if(temp->getLeft()!=nullptr)
{
temp->getLeft()->m_level=temp->m_level+1;
myQueue->enqueue(temp->getLeft());
}
if(temp->getRight()!=nullptr)
{
temp->getRight()->m_level=temp->m_level+1;
myQueue->enqueue(temp->getRight());
}
}
return;
}
void Queue<T>::enqueue(T *val)
{
#ifdef USE_CACHE_TOREUSE_NODES
Node<T> *add;
#else
Node<T> *add = new Node<T>(val);
#endif // USE_CACHE_TOREUSE_NODES
{
std::unique_lock<std::mutex> u(m);
#ifdef USE_CACHE_TOREUSE_NODES
if (cStart == nullptr)
{
add = new Node<T>(val);
}
else
{
add = cStart;
cStart = cStart->getNext();
add->setNext(nullptr);
add->setVal(val);
}
#endif // USE_CACHE_TOREUSE_NODES
tail->setNext(add);
tail = add;
}
dataAvi.notify_one();
}
