Tres tipos de inversión de una sola lista para probar la implementación de seguridad oferta-

reversión de cadena sencilla puede ser implementado por recursiva, no recursiva y la pila

Lista definición de nodo:

struct ListNode{
    int val;
    Node* next;
    ListNode(int x):val(x),next(nullptr){}
}

1, la pila

ListNode* reverseList(ListNode* head) {
    if(!head || !head->next)
       	return head;
    stack<ListNode*>stk;
    //将链表的结点全部压进栈
    while(head){
        stk.push(head);
        head = head->next;
    }
    ListNode*cur,*nxt;
    cur = nxt = stk.top();
    stk.pop();
    while(!stk.empty()){
        nxt ->next = stk.top();
        nxt = nxt ->next;
        stk.pop();
    }
    //最后一个结点的next记得要指向nullptr
    nxt ->next =nullptr;
    return cur;
}

2, recursiva

Recursiva, hasta el último nodo de la lista, con un puntero al nodo, como el nodo principal lista enlazada después de la inversión
en el procedimiento de devolución recursivo, por lo que el siguiente nodo del nodo al nodo que \ ((cabeza-> siguiente -> el siguiente = cabeza) \) ,
y dejar que el punto de nodo \ (NULL \) . Esta inversión de la realización de la cola de una lista paso a paso

PD: Las fotografías borradas de la infracción a la red

ListNode* reverseList(ListNode* head) {
    if(head==NULL || head->next==NULL)  
        return head;
    ListNode* ptr=reverseList(head->next);
    head->next->next=head;
    head->next=NULL;
    
	return ptr;
}

3, puntero doble

Dos nodos usando puntero nodo intermedio y un puntero \ (TEMP (utilizado para registrar la posición de un nodo del nodo actual) \) , que apuntan al nodo actual y el nodo anterior, el nodo actual, de modo que cada ciclo campo de puntero apunta a una para antes nodo

ListNode* reverseList(ListNode* head) {
    ListNode* cur=head;
    ListNode* pre=nullptr;
    while(cur)
    {
        ListNode* tmp=cur->next;
        cur->next=pre;
        pre=cur;
        cur=tmp;
    }
    return pre;
}