/** * Elimina un nodo que se encuentre en la lista ubicado por su posición. * * @param posicion en la cual se encuentra el nodo a eliminar. */ public void removerPorPosicion(int posicion) { // Verifica si la posición ingresada se encuentre en el rango // >= 0 y < que el numero de elementos del la lista. if (posicion >= 0 && posicion < tamanio) { // Consulta si el nodo a eliminar es el primero if (posicion == 0) { // Elimina el primer nodo apuntando al siguinte. inicio = inicio.getSiguiente(); } // En caso que el nodo a eliminar este por el medio // o sea el ultimo else { // Crea una copia de la lista. Nodo aux = inicio; // Recorre la lista hasta lleger al nodo anterior al eliminar. for (int i = 0; i < posicion - 1; i++) { aux = aux.getSiguiente(); } // Guarda el nodo siguiente al nodo a eliminar. Nodo siguiente = aux.getSiguiente(); // Elimina la referencia del nodo apuntando al nodo siguiente. aux.setSiguiente(siguiente.getSiguiente()); } // Disminuye el contador de tamaño de la lista. tamanio--; } }
/** * Inserta un nuevo nodo despues de otro, ubicado por el valor que contiene. * * @param referencia valor del nodo anterios al nuevo nodo a insertar. * @param valor del nodo a insertar. */ public void insertarPorReferencia(int referencia, int valor) { // Define un nuevo nodo. Nodo nuevo = new Nodo(); // Agrega al valor al nodo. nuevo.setValor(valor); // Verifica si la lista contiene elementos if (!esVacia()) { // Consulta si el valor existe en la lista. if (buscar(referencia)) { // Crea ua copia de la lista. Nodo aux = inicio; // Recorre la lista hasta llegar al nodo de referencia. while (aux.getValor() != referencia) { aux = aux.getSiguiente(); } // Crea un respaldo de la continuación de la lista. Nodo siguiente = aux.getSiguiente(); // Enlaza el nuevo nodo despues del nodo de referencia. aux.setSiguiente(nuevo); // Une la continuacion de la lista al nuevo nodo. nuevo.setSiguiente(siguiente); // Incrementa el contador de tamaño de la lista. tamanio++; } } }
/** * Elimina un nodo que se encuentre en la lista ubicado por un valor de referencia. * * @param referencia valor del nodo que se desea eliminar. */ public void removerPorReferencia(int referencia) { // Consulta si el valor de referencia existe en la lista. if (buscar(referencia)) { // Consulta si el nodo a eliminar es el pirmero if (inicio.getValor() == referencia) { // El primer nodo apunta al siguiente. inicio = inicio.getSiguiente(); } else { // Crea ua copia de la lista. Nodo aux = inicio; // Recorre la lista hasta llegar al nodo anterior // al de referencia. while (aux.getSiguiente().getValor() != referencia) { aux = aux.getSiguiente(); } // Guarda el nodo siguiente del nodo a eliminar. Nodo siguiente = aux.getSiguiente().getSiguiente(); // Enlaza el nodo anterior al de eliminar con el // sguiente despues de el. aux.setSiguiente(siguiente); } // Disminuye el contador de tamaño de la lista. tamanio--; } }
public int tamano() { int resultado = 0; Nodo<T> actual = raiz; while (actual != null) { actual = actual.getSiguiente(); resultado++; } return resultado; }
public int contar() { Nodo mNodo = Inicio; int contador = 0; while (mNodo != null) { mNodo = mNodo.getSiguiente(); contador++; } return contador; }
/** * Inserta un nuevo nodo despues en una posición determinada. * * @param posicion en la cual se va a insertar el nuevo nodo. * @param valor valor del nuevo nodo de la lista. */ public void insrtarPorPosicion(int posicion, int valor) { // Verifica si la posición ingresada se encuentre en el rango // >= 0 y <= que el numero de elementos del la lista. if (posicion >= 0 && posicion <= tamanio) { Nodo nuevo = new Nodo(); nuevo.setValor(valor); // Consulta si el nuevo nodo a ingresar va al inicio de la lista. if (posicion == 0) { // Inserta el nuevo nodo al inicio de la lista. nuevo.setSiguiente(inicio); inicio = nuevo; } else { // Si el nodo a inserta va al final de la lista. if (posicion == tamanio) { Nodo aux = inicio; // Recorre la lista hasta llegar al ultimo nodo. while (aux.getSiguiente() != null) { aux = aux.getSiguiente(); } // Inserta el nuevo nodo despues de del ultimo. aux.setSiguiente(nuevo); } else { // Si el nodo a insertar va en el medio de la lista. Nodo aux = inicio; // Recorre la lista hasta llegar al nodo anterior // a la posicion en la cual se insertara el nuevo nodo. for (int i = 0; i < (posicion - 1); i++) { aux = aux.getSiguiente(); } // Guarda el nodo siguiente al nodo en la posición // en la cual va a insertar el nevo nodo. Nodo siguiente = aux.getSiguiente(); // Inserta el nuevo nodo en la posición indicada. aux.setSiguiente(nuevo); // Une el nuevo nodo con el resto de la lista. nuevo.setSiguiente(siguiente); } } // Incrementa el contador de tamaño de la lista. tamanio++; } }
public boolean eliminar(String cadena) { boolean borrado = false; Nodo mNodo; Nodo antNodo; // Buscando el nodo con el número mNodo = this.Inicio; while ((mNodo != null) && (!mNodo.getDato().equals(cadena))) { mNodo = mNodo.getSiguiente(); } if (mNodo != null) { if (mNodo == this.Inicio) { this.Inicio = this.Inicio.getSiguiente(); } else if (mNodo == this.Fin) { // Llegar al anterior al fin antNodo = this.Inicio; while (antNodo.getSiguiente() != mNodo) { antNodo = antNodo.getSiguiente(); } this.Fin = antNodo; this.Fin.setSiguiente(null); } else { // Llengar al anterior al buscado antNodo = this.Inicio; while (antNodo.getSiguiente() != mNodo) { antNodo = antNodo.getSiguiente(); } antNodo.setSiguiente(mNodo.getSiguiente()); } borrado = true; } return borrado; }
/** * Actualiza el valor de un nodo que se encuentre en la lista ubicado por un valor de referencia. * * @param referencia valor del nodo el cual se desea actualizar. * @param valor nuevo valor para el nodo. */ public void editarPorReferencia(int referencia, int valor) { // Consulta si el valor existe en la lista. if (buscar(referencia)) { // Crea ua copia de la lista. Nodo aux = inicio; // Recorre la lista hasta llegar al nodo de referencia. while (aux.getValor() != referencia) { aux = aux.getSiguiente(); } // Actualizamos el valor del nodo aux.setValor(valor); } }
/** * Agrega un nuevo nodo al final de la lista. * * @param valor a agregar. */ public void agregarAlFinal(int valor) { // Define un nuevo nodo. Nodo nuevo = new Nodo(); // Agrega al valor al nodo. nuevo.setValor(valor); // Consulta si la lista esta vacia. if (esVacia()) { // Inicializa la lista agregando como inicio al nuevo nodo. inicio = nuevo; // Caso contrario recorre la lista hasta llegar al ultimo nodo // y agrega el nuevo. } else { // Crea ua copia de la lista. Nodo aux = inicio; // Recorre la lista hasta llegar al ultimo nodo. while (aux.getSiguiente() != null) { aux = aux.getSiguiente(); } // Agrega el nuevo nodo al final de la lista. aux.setSiguiente(nuevo); } // Incrementa el contador de tamaño de la lista tamanio++; }
public T get(int i) { if (raiz == null) throw new IndexOutOfBoundsException(); if (i == 0) return raiz.getContenido(); int resultado = 0; Nodo<T> actual = raiz; while (actual != null && resultado < i) { actual = actual.getSiguiente(); resultado++; } if (resultado == i) return actual.getContenido(); logger.error("Se busco la posicion " + i + " pero antes la cadena es nula"); throw new IndexOutOfBoundsException(); }
public int buscar(String cadena) { Nodo mNodo; int posicion = 0; // Buscando el nodo con el número if (this.Inicio != null) { mNodo = this.Inicio; while ((mNodo != null) && (!mNodo.getDato().equals(cadena))) { mNodo = mNodo.getSiguiente(); posicion++; } } else { posicion = -1; } return posicion; }
public boolean modificar(String cadenaanterior, String cadenanueva) { boolean modificado = false; Nodo mNodo; // Buscando el nodo con el número mNodo = this.Inicio; while ((mNodo != null) && (!mNodo.getDato().equals(cadenaanterior))) { mNodo = mNodo.getSiguiente(); } if (mNodo != null) { mNodo.setDato(cadenanueva); modificado = true; } return modificado; }
/** Mustra en pantalla los elementos de la lista. */ public void listar() { // Verifica si la lista contiene elementoa. if (!esVacia()) { // Crea una copia de la lista. Nodo aux = inicio; // Posicion de los elementos de la lista. int i = 0; // Recorre la lista hasta el final. while (aux != null) { // Imprime en pantalla el valor del nodo. System.out.print(i + ".[ " + aux.getValor() + " ]" + " -> "); // Avanza al siguiente nodo. aux = aux.getSiguiente(); // Incrementa el contador de la posión. i++; } } }
/** * Busca si existe un valor en la lista. * * @param referencia valor a buscar. * @return true si existe el valor en la lista. */ public boolean buscar(int referencia) { // Crea una copia de la lista. Nodo aux = inicio; // Bandera para indicar si el valor existe. boolean encontrado = false; // Recorre la lista hasta encontrar el elemento o hasta // llegar al final de la lista. while (aux != null && encontrado != true) { // Consulta si el valor del nodo es igual al de referencia. if (referencia == aux.getValor()) { // Canbia el valor de la bandera. encontrado = true; } else { // Avansa al siguiente. nodo. aux = aux.getSiguiente(); } } // Retorna el resultado de la bandera. return encontrado; }
/** * Consulta la posición de un elemento en la lista * * @param referencia valor del nodo el cual se desea saber la posición. * @return un valor entero entre [0,n] que indica la posición del nodo. * @throws Exception */ public int getPosicion(int referencia) throws Exception { // Consulta si el valor existe en la lista. if (buscar(referencia)) { // Crea una copia de la lista. Nodo aux = inicio; // COntado para almacenar la posición del nodo. int cont = 0; // Recoore la lista hasta llegar al nodo de referencia. while (referencia != aux.getValor()) { // Incrementa el contador. cont++; // Avansa al siguiente. nodo. aux = aux.getSiguiente(); } // Retorna el valor del contador. return cont; // Crea una excepción de Valor inexistente en la lista. } else { throw new Exception("Valor inexistente en la lista."); } }
/** * Actualiza el valor de un nodo que se encuentre en la lista ubicado por su posición. * * @param posicion en la cual se encuentra el nodo a actualizar. * @param valor nuevo valor para el nodo. */ public void editarPorPosicion(int posicion, int valor) { // Verifica si la posición ingresada se encuentre en el rango // >= 0 y < que el numero de elementos del la lista. if (posicion >= 0 && posicion < tamanio) { // Consulta si el nodo a eliminar es el primero. if (posicion == 0) { // Alctualiza el valor delprimer nodo. inicio.setValor(valor); } else { // En caso que el nodo a eliminar este por el medio // o sea el ultimo Nodo aux = inicio; // Recorre la lista hasta lleger al nodo anterior al eliminar. for (int i = 0; i < posicion; i++) { aux = aux.getSiguiente(); } // Alctualiza el valor del nodo. aux.setValor(valor); } } }
/** * Obtiene el valor de un nodo en una determinada posición. * * @param posicion del nodo que se desea obtener su valor. * @return un numero entero entre [0,n-1] n = numero de nodos de la lista. * @throws Exception */ public int getValor(int posicion) throws Exception { // Verifica si la posición ingresada se encuentre en el rango // >= 0 y < que el numero de elementos del la lista. if (posicion >= 0 && posicion < tamanio) { // Consulta si la posicion es el inicio de la lista. if (posicion == 0) { // Retorna el valor del inicio de la lista. return inicio.getValor(); } else { // Crea una copia de la lista. Nodo aux = inicio; // Recorre la lista hasta la posición ingresada. for (int i = 0; i < posicion; i++) { aux = aux.getSiguiente(); } // Retorna el valor del nodo. return aux.getValor(); } // Crea una excepción de Posicion inexistente en la lista. } else { throw new Exception("Posicion inexistente en la lista."); } }
@Override public M next() { M respuesta = actual.getContenido(); actual = actual.getSiguiente(); return respuesta; }