import java.util.

Iterator;
import java.util.Stack;
public class OrderedList<E extends Comparable<E>>
implements Iterable<E> {
AVLNode<E> AVLList = null;
int numItems = 0;
//checks to see if the node exists first
private int nodeHeight(AVLNode<E> n) {
if (n == null) {
return 0;
}
return n.getHeight();
}
//Changes parents for rotations
private void changeParent(AVLNode<E> parent, AVLNode<E> oldRoot, AVLNode<E>
newRoot) {
if (parent == null) {
this.AVLList = newRoot;
newRoot.setParent(null);
} else if (parent.getLeft() == oldRoot) {
parent.setLeft(newRoot);
} else {
parent.setRight(newRoot);
}
}
//right rotations
private AVLNode<E> rightRotate(AVLNode<E> root) {
AVLNode parent = root.getParent();
AVLNode newRoot = root.getLeft();
AVLNode LR = newRoot.getRight();
newRoot.setRight(root);
root.setLeft(LR);
int rightHeight = this.nodeHeight(root.getRight());
int leftHeight = this.nodeHeight(root.getLeft());
root.setHeight(Math.max(leftHeight, rightHeight) + 1);
this.changeParent(parent, root, newRoot);
return newRoot;
}
//left rotations
private AVLNode<E> leftRotate(AVLNode<E> root) {
AVLNode parent = root.getParent();
AVLNode newRoot = root.getRight();
AVLNode RL = newRoot.getLeft();
newRoot.setLeft(root);
root.setRight(RL);
int leftHeight = this.nodeHeight(root.getLeft());
int rightHeight = this.nodeHeight(root.getRight());
root.setHeight(Math.max(leftHeight, rightHeight) + 1);
this.changeParent(parent, root, newRoot);
return newRoot;
}
//Used to balance the tree if the tree is unbalanced
private void balanceTree(AVLNode<E> root) {
int leftHeight;

if (root == null) {
return;
}
AVLNode left = root.getLeft();
AVLNode right = root.getRight();
int rightHeight = this.nodeHeight(right);
int currentBalance = rightHeight - (leftHeight = this.nodeHeight(left));
if (currentBalance > 1) {
if (this.nodeHeight(right.getLeft()) > this.nodeHeight(right.getRigh
t())) {
right = this.rightRotate(right);
}
root = this.leftRotate(root);
} else if (currentBalance < -1) {
if (this.nodeHeight(left.getRight()) > this.nodeHeight(left.getLeft(
))) {
left = this.leftRotate(left);
}
root = this.rightRotate((AVLNode)root);
}
leftHeight = this.nodeHeight(root.getLeft());
rightHeight = this.nodeHeight(root.getRight());
((AVLNode)root).setHeight(Math.max(leftHeight, rightHeight) + 1);
this.balanceTree(((AVLNode)root).getParent());
}
//insert new nodes
private E insert(AVLNode<E> root, E element) {
Comparable currentData = (Comparable)root.getData();
if (currentData.compareTo(element) == 0) {
return (E)currentData;
}
if (currentData.compareTo(element) > 0) {
AVLNode left = root.getLeft();
if (left == null) {
left = new AVLNode(element, (AVLNode<E>)null);
++this.numItems;
root.setLeft(left);
this.balanceTree(root);
return element;
}
return (E)this.insert(left, element);
}
AVLNode right = root.getRight();
if (right == null) {
right = new AVLNode(element, (AVLNode<E>)null);
++this.numItems;
root.setRight(right);
this.balanceTree(root);
return element;
}
return (E)this.insert(right, element);
}
//CHecks to see if element exists in AVL list
public E findOrAdd(E element) {
if (this.AVLList == null) {
this.AVLList = new AVLNode(element, (AVLNode<E>)null);

this.numItems = 1;
return element;
}
return (E)this.insert(this.AVLList, element);
}
//Get number of items
public int getNumItems() {
return this.numItems;
}
@Override
public Iterator<E> iterator() {
return new OrdListIterator();
}
//Parameters for AVL Nodes to maintain order
private class AVLNode<E>
{
private E data;
private AVLNode<E> left;
private AVLNode<E> right;
private AVLNode<E> parent;
private int height;
private AVLNode(final E newData, final AVLNode<E> r, final AVLNode<E> l,
final AVLNode<E> p) {
this.data = newData;
this.left = l;
this.right = r;
this.parent = p;
this.height = 1;
}
private AVLNode(final E newData, final AVLNode<E> p) {
this.data = newData;
this.parent = p;
this.left = null;
this.right = null;
this.height = 1;
}
private E getData() {
return this.data;
}
private AVLNode<E> getLeft() {
return this.left;
}
private AVLNode<E> getRight() {
return this.right;
}
private AVLNode<E> getParent() {
return this.parent;
}

//set values for rotations or insertions.

private void setParent(final AVLNode<E> n) {
this.parent = n;
}
private void setLeft(final AVLNode<E> l) {
this.left = l;
if (l != null) {
l.parent = this;
}
}
private void setRight(final AVLNode<E> r) {
this.right = r;
if (r != null) {
r.parent = this;
}
}
//Get and sets the heights for rotations and inserts
private int getHeight() {
return this.height;
}
private void setHeight(final int h) {
this.height = h;
}
}
private class OrdListIterator
implements Iterator<E> {
Stack<AVLNode<E>> iterStack;
public OrdListIterator() {
this.iterStack = new Stack();
AVLNode node = OrderedList.this.AVLList;
while (node != null) {
this.iterStack.push(node);
node = node.getLeft();
}
}
@Override
public boolean hasNext() {
return !this.iterStack.isEmpty();
}
@Override
public E next() {
AVLNode node = (AVLNode)this.iterStack.pop();
AVLNode nextNode = node.getRight();
while (nextNode != null) {
this.iterStack.push(nextNode);
nextNode = nextNode.getLeft();
}
return (E)((Comparable)node.getData());
}
@Override
public void remove() {

throw new UnsupportedOperationException("This linked list implementa

tion does not support Remove()");
}
}
}