Lista de enlaces inversos de Niuke

describir

Dado el nodo principal PHead de una lista con un solo enlace (el nodo principal tiene un valor, por ejemplo, en la figura a continuación, su valor es 1), la longitud es n, después de invertir la lista enlazada, devuelve el encabezado del nuevo enlace lista.

Rango de datos: 0≤n≤1000

Requisitos: complejidad espacial O(1), complejidad temporal O(n).

Por ejemplo, al ingresar la lista enlazada {1,2,3},

Después de la inversión, la lista enlazada original se convierte en {3,2,1}, por lo que la salida correspondiente es {3,2,1}.

El proceso de conversión anterior se muestra en la siguiente figura:

Ejemplo 1

ingresar:

{1,2,3}

Copiar valor de retorno:

{3,2,1}

Copiar

Ejemplo 2

ingresar:

{}

Copiar valor de retorno:

{}

Instrucciones de copia:

Salidas de listas enlazadas vacías vacías

Solución 1 (c)

Inicialización: 3 punteros
1) El puntero pre apunta al último nodo de la lista vinculada que se ha invertido, y no hay inversión al principio, por lo que apunta a NULL
2) El puntero cur apunta al primer nodo de la lista vinculada lista que se invertirá, el primer nodo al principio El nodo se invertirá, por lo que apunta a la cabeza
3) El puntero nex apunta al segundo nodo de la lista vinculada que se invertirá, el propósito es guardar la lista vinculada, porque después de que cur cambie el puntero, la siguiente lista vinculada dejará de ser válida, por lo que debe guardarse A continuación, ejecute lo siguiente en un
bucle Tres operaciones
1) nex = cur->next, guarde la función
2) cur->next = pre El siguiente puntero del primer nodo de la lista enlazada no invertida apunta al último nodo de la lista enlazada invertida
3) pre = cur, cur = nex; mueve el puntero hacia atrás, opera el primer nodo de la siguiente lista enlazada no invertida La
condición del ciclo , por supuesto, es cur != NULL
Después de que finaliza el bucle, cur es, por supuesto, NULL, por lo que devuelve pre, que es el punto de encabezado invertido

código:

struct ListNode* ReverseList(struct ListNode* pHead ) {
    // write code here
    
    if (pHead==NULL) return NULL;
    
    struct ListNode *pre=NULL;
    struct ListNode *cur=pHead;
    struct ListNode *nex=NULL;
    
    while(cur){
        nex=cur->next;
        cur->next=pre; //未反转链表的第一个节点的下个指针指向已反转链表的最后一个节点
        pre=cur;
        cur=nex;
    }
    return pre;
}

 Solución 2 (c++)

Construya una lista enlazada, use el vector para almacenar primero y luego construya

Complejidad de tiempo: O(n)
Complejidad de espacio: O(n), se utiliza un vector para almacenar una sola lista enlazada

código:

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        
        if(!pHead) return nullptr;
        vector<ListNode*> v;
        while(pHead){
            v.push_back(pHead);
            pHead=pHead->next;
        }
        reverse(v.begin(), v.end()); //反转vector 或者逆向遍历
        ListNode *head=v[0];
        ListNode *cur=head;
        for(int i=1;i<v.size();i++){ //构造链表
            cur->next=v[i]; //当前节点的下一个指针指向下一个节点
            cur=cur->next;  //当前指针后移
        }
        cur->next=nullptr;  //切记最后一个节点的下一个指针指向nullptr
        return head;
    }
};

Solución 3 (Java) 

Usando una pila, la pila es la primera en entrar, la última en salir

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.Stack;
public class Solution {
    public ListNode ReverseList(ListNode head) {
    Stack<ListNode> stack =new Stack<>();
      //把链表节点全部摘掉放到栈中
   while(head!=null){
       stack.push(head);
       head=head.next;
    }
    if(stack.isEmpty()) return null;
    ListNode node=stack.pop();
    ListNode dummy =node;
    //栈中的结点全部出栈，然后重新连成一个新的链表
    while(!stack.isEmpty()){
       ListNode tempnode=stack.pop();
       node.next=tempnode;
       node=node.next;
    }
    //最后一个结点就是反转前的头结点，一定要让他的next
    //等于空，否则会构成环
    node.next=null;
    return dummy;

    }
}