c++ - 交换单链表节点创建一个无限循环

Question

我的节点有一个整数值。我希望我的程序使用这样的值交换两个节点:

void reemplazarNodosConValores(int a,int b) {
    node *antecedenteDelPrimero = antecedentePorValor(a);
    node *antecedenteDelSegundo = antecedentePorValor(b);
    node *primero = nodoPorValor(a);
    node *segundo = nodoPorValor(b);
    node *nextDelPrimero = siguienteNodo(primero);
    node *nextDelSegundo = siguienteNodo(segundo);


    antecedenteDelSegundo->next = primero;
    primero->next = nextDelSegundo;

    antecedenteDelPrimero->next = segundo;
    segundo->next = nextDelPrimero;
}

如您所见，我创建了六个变量。两个节点。每个节点之前的节点。以及每个节点之后的节点。

然后，我进行交换。

但是，当我尝试打印我的节点时，交换似乎会产生一个无限循环。

我的交换基于这个答案:https://stackoverflow.com/a/1536011/555690

编辑:其他功能，按要求:

node *antecedentePorValor(int x) {
    node *resultado = NULL;
    for (int i = 0; i < counter; ++i) {
        resultado = siguienteNodo(resultado);
        if (siguienteNodo(resultado)) {
            if (siguienteNodo(resultado)->data == x) {
                break;
            }
        }
    }
    return resultado;
}

node *nodoPorValor(int x) {
    node *resultado = head;
    for (int i = 1; i < counter; ++i) {
        if (resultado->data == x) {
            break;
        }
        resultado = resultado->next;
    }
    return resultado;
}

node *siguienteNodo(node *nodo) {
    node *resultado;
    if (nodo) {
        resultado = nodo->next;
    }else{
        resultado = head;
    }
    return resultado;
}

Answer 1

有几种情况需要注意

1. 值为b 的节点紧跟在值为a 的节点之后，反之亦然
2. 值为a或b的节点是列表中的第一个节点
3. 有多个节点的值为a或值为b

如果不查看函数 antecedentePorValor 和 nodoPorValor 的代码，就无法判断您是否对案例 2 或案例 3 有问题。案例 #1 存在错误。

编辑:为了说明#1 存在错误的原因，假设节点 (a) 指向节点 (b)，然后

void reemplazarNodosConValores(int a,int b) {
    node *antecedenteDelPrimero = antecedentePorValor(a); // node preceding a
    node *antecedenteDelSegundo = antecedentePorValor(b); // node preceding b (a)
    node *primero = nodoPorValor(a);                      // node that contains a
    node *segundo = nodoPorValor(b);                      // node that contains b
    node *nextDelPrimero = siguienteNodo(primero);        // node following a (b)
    node *nextDelSegundo = siguienteNodo(segundo);        // node following b


    antecedenteDelSegundo->next = primero; // a->next = a
    primero->next = nextDelSegundo;        // a->next = node following b

    antecedenteDelPrimero->next = segundo; // preva->next = b
    segundo->next = nextDelPrimero;        // b->next = b <<== b points to self!!
}

在评论中，我使用简写 preva 表示 antecedenteDelPrimero 和 a 表示 primero 和 b 表示 segundo。