#include <iomanip.h>
#include <assert.h>
#include "llist4.h"

llist::llist() {
	next = 0;
}

int llist::getdata() {
	return data;
}

llist* llist::getnext() {
	return next;
}

void llist::setdata(int d) {
	data = d;
}

void llist::setnext(llist *n) {
	next = n;
}

int llist::getlength() {
	if (next == 0) return 1;
	else return 1 + next->getlength();
}

int& llist::getitem(int index) {
	assert((index < getlength()) && (index >= 0));
	if (index == 0) return data;
	else return next->getitem(index - 1);
}

void llist::setitem(int index, int v) {
	assert((index < getlength()) && (index >= 0));
	if (index == 0) data = v;
	else next->setitem(index - 1, v);
}

int& llist::operator [] (int index) {
	return getitem(index);
}

void llist::add(int newval) {
	if (next == 0) {
		next = new llist;
		next->data = newval;
	}
	else next->add(newval);
}

llist& llist::operator <<(const int newval) {
	add(newval);
	return *this;
}

llist::llist(int size) {
	for (int a = 1; a < size; a++) 
		add(0);
}

llist::llist(int size, int defaultvalue) {
	data = defaultvalue;
	for (int a = 1; a < size; a++) 
		add(defaultvalue);
}

llist::~llist() {
	if (next != 0)
		delete next;
}

void llist::ridlast() {
	if (next->next == 0) {
		delete next;
		next = 0;
	}
	else next->ridlast();
}

llist::llist(llist &rhs) {
	data = rhs.data;
	for (int a = 1; a < rhs.getlength(); a++) 
		add(rhs[a]);
}

llist& llist::operator+= (llist &rhs) {
	for (int a = 0; a < rhs.getlength(); a++) 
		add(rhs[a]);
	return *this;
}
// cannot insert before the first element
void llist::insert(int d, int index) {
	llist *temp;
	assert(index < getlength());
	if (index == 1) {
		// save the next node
		temp = next;
		// add a new node 
		next = new llist;
		// set its data
		next->data = d;
		// attach what used to be the next node to the new next node
		next->next = temp;
	}
	else next->insert(d, index-1);
}


void llist::remove(int index) {
	llist *temp;
	assert(index < getlength());
	if (index == 1) { 
		// save the pointer to the node after the one we're deleting
		temp = next->next;
		// isolate the node we want to delete
		next->next = 0;
		// delete it
		delete next;
		// then set the next node to be the one after we just deleted
		next = temp;
	}
	else next->remove(index-1);
}

llist& llist::operator = (llist& rhs) {
	// remove all nodes beyond this one
	delete next; 
	// set this node as the end of the list
	next = 0;
	// copy the first node of rhs's data
	data = rhs.data;
	// then add copies of the other nodes into our list
	for (int a = 1; a < rhs.getlength(); a++) 
		add(rhs[a]);
	return *this;
}

void llist::resize(int newsize) {
	if (getlength() > newsize) 
		for (int a = getlength(); a > newsize; a--)
			ridlast();
	else
		for (int a = getlength(); a < newsize; a++)
			add(0);
}

void llist::sort() {
	int temp;
	for (int a = getlength(); a > 1; a--) 
		for (int b = 1; b < a; b++) {
			if (getitem(b) > getitem(a)) {
				temp = getitem(b);
				getitem(b) = getitem(a);
				getitem(a) = temp;
			}
		}
}

llist* llist::find(int value) {
	if (data == value) return this;
	else return next->find(value);
}

llist* llist::smaller(int value) {
	sort();
	if (next->data > value) return this;
	else return next->smaller(value);
}

void main() {
	llist data, data1;
	data.setdata(0);
	data << 34;
	data << 12;
	data1[0] = 120;
	data1 << 200;
	data1 << 100;
	cout << data[0] << data[1] << data[2] << endl;
	data[0] = 3;
	cout << data[0] << data[1] << data[2] << endl;
	data += data1;
	for (int a = 0; a < data.getlength(); a++) 
		cout << data[a] << " ";
	cout << endl;
}