bool LinkedList::removeFromBack(string &output)
{
if (!isEmpty())
{
ListNode* currNode = head;
ListNode* prevNode;
// move to second last node
while (currNode->getNext() != NULL)
{
prevNode = currNode;
currNode = currNode->getNext();
}
output = currNode->value;
delete currNode;
prevNode->next = NULL;
last = prevNode;
}
else
{
return false;
}
}
bool List::remove(Object* const object)
{
bool objectFound = false;
ListNode* temp = this->first;
ListNode* prev = NULL;
ListNode* next = NULL;
while( temp != NULL ) {
if (object == temp->getObject()) {
next = temp->getNext();
delete temp;
if(next == NULL)
last = NULL;
if(prev == NULL)
first = next;
else
prev->setNext(next);
objectFound = true;
break;
}
prev = temp;
temp = temp->getNext();
}
return objectFound;
}
void LinkedList::printList(ofstream& out){
out << "ListHead --> (" << listHead->getData() << ", " << listHead->getNext() << ") ";
ListNode* temp = listHead->getNext();
while(temp != NULL){
out << "--> (" << temp->getData() << ", " << temp->getNext() << ") ";
temp = temp->getNext();
}
out << endl;
}
ListNode* LinkedList::findSpot(int input){
if(isEmpty()){
return listHead;
}
ListNode* temp = listHead;
while(temp->getNext() != NULL && temp->getNext()->getData() < input){
temp = temp->getNext();
}
return temp;
}
ListIterator<Object> List<Object>::findPrevious( const Object& data ) const {
ListNode<Object>* node = head;
while( node->getNext() != NULL && node->getNext()->getElement() != data ) {
node = node->getNext();
}
if (node->getNext() == NULL) {
node = NULL;
}
return ListIterator<Object>( node );
}
// Show the contents of the list
void LinkedList::print(void)
{
ListNode *node = head.getNext();
while (node != 0) {
cout << setw(6) << node->getVal();
node = node->getNext();
}
cout << endl;
}
void List<Object>::remove( const Object& data ) {
ListIterator<Object> iter = findPrevious( data );
if (iter.isValid()) {
ListNode<Object>* node = findPrevious( data ).current;
if (node->getNext() != NULL) {
ListNode<Object> *oldNode = node->getNext();
node->setNext( node->getNext()->getNext() ); // Skip oldNode
delete oldNode;
}
}
}
// Insert in sorted order (ascending)
ListNode * LinkedList::insert(const int val)
{
ListNode *node = head.getNext();
ListNode *prev = &head;
while (node != 0 && node->getVal() < val) {
prev = node;
node = node->getNext();
}
return prev->setNext(new ListNode(val, prev->getNext()));
}
void LinkedList::listInsert(int input, ofstream& out){
ListNode* spot = findSpot(input);
if(spot->getNext() != NULL){
if(spot->getNext()->getData() == input){
out << input << " is already in the list." << endl;
return;
}
}
ListNode* temp = new ListNode(input, spot->next);
spot->next = temp;
printList(out);
}
// Look for a node having the specified value
ListNode * LinkedList::find(const int val)
{
ListNode *node = head.getNext();
while (node != 0 && node->getVal() != val) {
node = node->getNext();
}
if (node->getVal() == val) {
return node;
}
return 0;
}
void List::Print() const {
if(head==NULL)
cout << "The list is empty." << endl << endl;
else{
cout << "The current list is as follows:" << endl << endl;
ListNode * index = head;
cout << index->getMyInt() << endl;
while(index->getNext()!=NULL){
index=index->getNext();
cout << index->getMyInt() << endl;
}
cout << endl << endl;
}
}
Item List::get(int n){
if(n <= 0) return Item("Integer invalid");
ListNode *k = head->getNext();
if(k == NULL) return Item("Not enough items"); //No items
if(n == 1) return Item(head->getItem()); //First item on the list
for(int i = 2; i < n ; i++){
k = k->getNext();
if(k == NULL) return Item("Not enough items");
}
return Item(k->getItem()); //Returns the item of n on the list
}
bool List::member(ICollectible *c) const{
for(ListNode *current = head; current != NULL; current = current->getNext())
if(current->getElem() == c)
return true;
return false;
}
// Remove the first node having the specified value (if present)
int LinkedList::remove(const int val)
{
ListNode *node = head.getNext();
ListNode *prev = &head;
while (node != 0 && node->getVal() != val) {
prev = node;
node = node->getNext();
}
if (node->getVal() == val) {
prev->setNext(node->getNext());
delete node;
return val;
}
return -1;
}
int List::length(){
int counter = 0;
if(empty()) return 0;
ListNode *n = head->getNext();
if(n == NULL){
return 1;
}
else{
counter++; //list had at least 1 item
while (n != NULL){ // while list is not empty
counter++;
n = n->getNext();
}
return counter; //Returns the # of items in the list
}
}
vector< Point2d > PointPersistentList::enumerateNE(coord_t x, coord_t y) {
vector< Point2d > v;
// determine the time at which to search by searching for the x
int index = binarySearchX(x);
// if set of points is empty, bail out
if(index == -1) return v;
// while the closest point is too small
while(points_sorted_by_x[index].x < x) {
// check the previous point, which should be larger since the
// array is sorted by x descending
--index;
// if we have passed the beginning of the array, then there are no
// points within the query region
if(index < 0)
return v;
}
// get the first node in this list at time index
ListNode<Point2d, Point2d::yxdesc >* pln = points_right.getList(index);
// while the current point is not null and has a greater or equal
// y than the query
while(pln != NULL && pln->data.y >= y) {
// push the point onto the list to be returned
v.push_back(pln->data);
// move on to next point
pln = pln->getNext(index);
}
return v;
}
void List::copy(List L){
Head = NULL;
ListNode * temp = L.Head;
while(temp!=NULL){
this->append(temp->getData());
temp=temp->getNext();
}
}
// Add to the end of the list
ListNode * LinkedList::append(const int val)
{
ListNode *node = &head;
while (node->hasNext()) {
node = node->getNext();
}
return node->setNext(new ListNode(val));
}
List::~List() {
ListNode *current = head;
ListNode *next;
while (current != NULL) {
next = current->getNext();
delete current;
current = next;
}
}
void* PtrListIterator::next()
{
if(_lead==NULL)
throw IndexOutOfBoundsException();
void* element = _lead->getElement();
_lead = _lead->getNext();
return element;
}
void List::remove(ICollectible *c)
{
ListNode *current = head;
ListNode *previous = NULL;
while(current != NULL && current->getElem() != c){
previous = current;
current = current->getNext();
}
if(current == NULL){ // final de la lista, no estaba
return;
} else if(current->getElem() == c){ // ya está, se borra
--size;
if(previous == NULL) // se borra el primer elemento
head = current->getNext();
else
previous->setNext(current->getNext());
delete current;
}
}
ostream & operator<<(ostream & stream, const LinkedList & list )
{
ListNode* currNode = list.head;
while (currNode != NULL)
{
cout << currNode->getValue();
currNode = currNode->getNext();
}
return stream;
}
ListIterator::~ListIterator()
{
if(disposeHeadOnDelete){
ListNode *n = head;
while(n != NULL){
ListNode *deleteMe = n;
n = n->getNext();
delete deleteMe;
}
}
}
/*---------------------------------------------------------------------*//**
コピー
**//*---------------------------------------------------------------------*/
void ProgMatter::Setting::copy(const Setting* s)
{
// _listParams のコピー
{
_listParams->removeAll();
ListNode<KeyValue*>* lnode = s->_listParams->getHeadNode();
while(lnode != 0L)
{
_listParams->addTail(new KeyValue(*lnode->getObject()));
lnode = lnode->getNext();
}
}
}
Point2d* PointPersistentList::leftMostNE(coord_t x, coord_t y) {
Point2d* leftMost = NULL;
// determine the time at which to search by searching for the x
int index = binarySearchX(x);
// if set of points is empty, bail out
if(index == -1) return NULL;
// while the closest point is too small
while(points_sorted_by_x[index].x < x) {
// check the previous point, which should be larger since the
// array is sorted by x descending
--index;
// if we have passed the beginning of the array, then there are no
// points within the query region
if(index < 0)
return NULL;
}
// get the first node in this list at time index
ListNode<Point2d, Point2d::yxdesc >* pln = points_right.getList(index);
// if there are no points NE of the given point, return null
if(pln == NULL || pln->data.y < y) return NULL;
// take the first point as left most for now
leftMost = &(pln->data);
// set pln to its next pointer
pln = pln->getNext(index);
// iterate over nodes in the list until:
// - we reach the end
// OR
// - the points are no longer NE of the query point
while(pln != NULL && pln->data.y >= y) {
// check if point is more left than current left most
if(pln->data.x < leftMost->x)
leftMost = &(pln->data);
// set pln to its next pointer
pln = pln->getNext(index);
}
// return the left most point
return leftMost;
}
void LinkedList::remove(const string &value)
{
ListNode* currNode = head;
ListNode* prevNode;
if (head == NULL) return;
while (currNode != NULL)
{
if (currNode->getValue() == value)
{
if (prevNode != NULL)
prevNode->next = currNode->getNext();
else
head = currNode->getNext();
delete currNode;
}
prevNode = currNode;
currNode = currNode->getNext();
}
last = currNode;
}
ListNode *LinkedList::search(const string &value)
{
ListNode* currNode = head;
if (head == NULL) return NULL;
while (currNode != NULL)
{
if (currNode->getValue() == value)
return currNode;
currNode = currNode->getNext();
}
}
bool List::remove(Item ©)
{
if (!empty()) // if list is not empty
{
copy = head->getItem(); // return copy
ListNode *tmp = head->getNext();
delete head; // delete the node
head = tmp; // update the head
if (tmp==NULL) // removed last element
tail = NULL;
return true;
}
return false; // nothing in list
}
ostream& operator<<(ostream &stream, const LinkedList &l) {
stream << "[";
ListNode *i = l.head;
while(i != NULL) {
stream << i->getValue();
i = i->getNext();
if(i != NULL)
stream << ", ";
}
stream << "]";
}
void List::Insert(int newInt){
if(head==NULL){
ListNode * h = new ListNode(newInt,NULL);
head=h;
}
else{
ListNode * index = head;
ListNode * prev = NULL;
ListNode * newListNode = new ListNode(newInt);
while(index->getNext()!=NULL && index->getMyInt()<=newInt){
prev=index;
index=index->getNext();
}
if(index->getMyInt()>newInt){
newListNode->setNext(index);
if(prev!=NULL)
prev->setNext(newListNode);
else
head=newListNode;
}
else
index->setNext(newListNode);
}
}