/**
* Elimina el nodo acual y devuelve el valor grabado en dicho nodo
* Side effects: el nodo actual debe moverse a uno de los nodos adyacentes
* (si existe) del nodo borrado
* @return el valor grabado en la posicion actual
*/
public int remove()
{
if (size == 0)
{
throw new EmptyListException();
}
int ret = curent.value;
if (size == 1)
{
curent = null;
size = 0;
return(ret);
}
CLinkNode prev = curent.prev;
CLinkNode next = curent.next;
prev.next = next;
next.prev = prev;
size--;
curent = next;
return(ret);
}
/**
* Agrega el valor val a la lista
* Side effects: El nodo actual se mueve al nuevo nodo creado
* @param val valor a agregar a la lista
*/
public void add(int val)
{
if (size == 0)
{
CLinkNode newNode = new CLinkNode(val);
newNode.next = newNode;
newNode.prev = newNode;
curent = newNode;
}
if (size == 1)
{
CLinkNode newNode = new CLinkNode(val);
newNode.prev = curent;
newNode.next = curent;
curent.next = newNode;
curent.prev = newNode;
}
if (size > 1)
{
CLinkNode newNode = new CLinkNode(val);
newNode.prev = curent.prev;
newNode.next = curent;
curent.prev.next = newNode;
curent.prev = newNode;
}
size++;
}
/**
* Agrega el valor val a la lista
* Side effects: El nodo actual se mueve al nuevo nodo creado
* @param val valor a agregar a la lista
*/
public void add(int val)
{
// TODO: implementar
// NOTA: puedes insertar el valor en cualquier posicion de la lista,
// teniendo en cuenta la complejidad deseada y el codigo que
// tendras que escribir en la clase Lab2c
// Complejidad esperada: O(1) en worst-case
// Valor: 3 puntos
CLinkNode newNode = new CLinkNode(val);
if (size == 0)
{
newNode.next = newNode;
newNode.prev = newNode;
cur = newNode;
size = 1;
return;
}
CLinkNode nxt = cur.next;
newNode.prev = cur;
newNode.next = nxt;
cur.next = newNode;
nxt.prev = newNode;
cur = newNode;
size++;
}
/**
* Elimina el nodo acual y devuelve el valor grabado en dicho nodo
* Side effects: el nodo actual debe moverse a uno de los nodos adyacentes
* (si existe) del nodo borrado
* @return el valor grabado en la posicion actual
*/
public int remove()
{
if (size == 0)
{
throw new EmptyListException();
}
// TODO: implementar
// Complejidad esperada: O(1) en worst-case
// Valor: 3 puntos
int ret = cur.value;
if (size == 1)
{
cur = null;
size = 0;
return(ret);
}
CLinkNode prv = cur.prev;
CLinkNode nxt = cur.next;
prv.next = nxt;
nxt.prev = prv;
size--;
cur = nxt;
return(ret);
}
/**
* Mueve el nodo actual 'cur' steps pasos.
* Si steps es positivo, se mueve hacia adelante
* Si steps es negativo, mueve hacia atras
* Si steps == 0, se queda donde esta
* @param la cantidad de pasos a moverse
*/
public void moveTo(int steps)
{
// TODO: implementar
// Complejidad esperada: O(min(|steps|, N)) en worst-case, donde steps
// es el parametro de este metodo
// OJO: Es posible que |steps| > N
// Valor: 2 puntos
if (steps == 0)
{
return;
}
if (steps > 0)
{
for (int i = 0; i < steps; i++)
{
cur = cur.next;
}
}
else
{
steps = -steps;
for (int i = 0; i < steps; i++)
{
cur = cur.prev;
}
}
}
/**
* Devuelve el valor grabado en el nodo actual
* @return el valor en el nodo actual
**/
public int get()
{
if (size == 0)
{
throw new EmptyListException();
}
int ret = curent.value;
curent = curent.next;
return(ret);
}
/**
* Localiza el valor en la lista, reposicionando el nodo actual al nodo
* que contiene dicho valor. Si la lista contiene multiples valores
* duplicados, puedes elegir cualquiera.
* @param val valor a buscar en la lista
* @return true si lo encuentra; de lo contrario, devuelve false
*/
public bool locate(int val)
{
for (int i = 0; i < size; i++)
{
if (curent.next.value == val)
{
curent = curent.next;
return(true);
}
curent = curent.next;
}
return(false);
}
override public string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("size = ");
sb.Append(size);
sb.Append(" elementos = (");
CLinkNode cur = curent;
for (int i = 0; i < size; i++)
{
sb.Append(" ");
sb.Append(cur.value);
cur = cur.next;
}
sb.Append(" )");
return(sb.ToString());
}
/**
* Localiza el valor en la lista, reposicionando el nodo actual al nodo
* que contiene dicho valor. Si la lista contiene multiples valores
* duplicados, puedes elegir cualquiera.
* @param val valor a buscar en la lista
* @return true si lo encuentra; de lo contrario, devuelve false
*/
public bool locate(int val)
{
// TODO: implementar
// Complejidad esperada: O(N) en worst-case
// Valor: 1 punto
CLinkNode x = cur;
for (int i = 0; i < size; i++)
{
if (x.value == val)
{
cur = x;
return(true);
}
x = x.next;
}
return(false);
}
/**
* Mueve el nodo actual 'cur' steps pasos.
* Si steps es positivo, se mueve hacia adelante
* Si steps es negativo, mueve hacia atras
* Si steps == 0, se queda donde esta
* @param la cantidad de pasos a moverse
*/
public void moveTo(int steps)
{
if (steps == 0)
{
}
if (steps > 0)
{
for (int i = 0; i < steps; i++)
{
curent = curent.next;
}
}
if (steps < 0)
{
int ret = steps * -1;
for (int i = 0; i < ret; i++)
{
curent = curent.prev;
}
}
}
