¿Por qué falla este método para encontrar la enésima posición de un nodo en una lista vinculada?

En primer lugar: no está buscando la enésima posición, está buscando el primer nodo que contiene el valor del elemento.

¿A qué se dirige la cabeza?

¿Cuál es el tipo de elemento (y datos curr.)? ¿Cuerda?

¿Cómo se define el nodo? ¿Es este? Nodo (Java Platform SE 7)

En una situación como esta, escribiría una función de depuración que muestra el contenido de la lista vinculada.

Errar.

En realidad, estás comparando el elemento con los datos en el nodo actual. A menos que haya escrito un método igual igual que no va a funcionar. Cámbielo a lo siguiente en la línea 5:

if (element.data.equals (curr.data)) {

Y deberías estar listo para irte.

¡Buena suerte!

Bueno, antes que nada déjame formatear esto de una manera que no me haga querer sacarme los ojos:

public int positionOfElement (elemento T) {
int index = 0;
Nodo curr = cabeza;
while (curr! = null) {
if (element.equals (curr.data)) {
índice de retorno;
}
index ++;
curr = curr.next;
}
volver -1;
}

Aquí vamos. Entonces, estás tomando una aguja, un elemento y corriendo a través de la lista de manera lineal, comenzando en la cabeza e intercambiando el nodo actual hasta que llegas a un partido o llegas al final de la lista, en cuyo caso Volvería -1.

Parece un razonamiento decente.

Lo inmediato que viene a la mente es el hecho de que estás comparando un elemento con los datos del currículum.

¿El elemento es un nodo? ¿Es del mismo tipo que los datos, y en realidad es la variable que desea comparar con la variable de datos?

Ahí es donde miraría. El resto parece estar bien.

Ok, sin conocer el contexto del problema es difícil encontrar la razón por la cual este método “falla” (lo que sea que eso signifique). Se me ocurren algunas posibilidades:

1. Node.data no es del tipo T , por lo que equals nunca devuelve true .
2. T no anula correctamente el método equals (la implementación predeterminada compara las direcciones de memoria, por lo que devolverá false para diferentes instancias incluso si son idénticas en contenido).
3. La lista vinculada tiene una falla de implementación (por ejemplo, un ciclo) que impide que la iteración llegue al elemento correcto o al final de la lista.
4. element es null , lo que provoca una NullPointerException en la línea 5.
5. La lista contiene más de 2,147,483,647 elementos (es decir, Integer.MAX_VALUE ), por lo que el index++ causará un desbordamiento.

Se necesita más contexto, así como la naturaleza exacta de la falla. Suponiendo que este método vive en una estructura de datos construida correctamente, el algoritmo parece teóricamente correcto. Sugiero pasar por él con un depurador y ver dónde está haciendo algo diferente a lo que quieres. Es probable que el problema esté en algún otro método.

Sospecho que el tipo de elemento “if (element.equals (curr.data))” y el tipo de datos del nodo deben ser iguales. Si obtiene un valor de -1, se confirma que está cometiendo un error al comparar datos de elementos y nodos.

El código es feo, pero parece que debería funcionar.

Probablemente hay un error en la función “igual” – o tal vez la lista vinculada no está construida correctamente … tal vez el constructor de copia para “Nodo” hace algo extraño. Usaría un puntero a un Nodo … pero entonces no sé cómo definiste “Nodo”.

int positionOfElement (elemento T)
{
int index = 0;
for (Node * curr = & head; curr! = null; curr = curr-> next)
{
if (element.equals (curr-> data)) índice de retorno;
index ++;
}
volver -1;
}

Es porque el tipo de datos de los elementos bajo si la condición NO es la misma.

después de cambiarlo, debería funcionar correctamente.

La lógica general se ve bien, sin embargo, como muchas otras publicaciones han dicho, parece que está comparando un Nodo con los datos en el nodo, lo que probablemente no sea así como funciona, a menos que lo haya anulado en su clase de Nodo (poco probable) o los datos en sí mismo es un nodo (también poco probable).