Inversão de lista encadeada unidirecional Java

Eu vi uma pergunta de entrevista há dois dias: inversão de lista vinculada unidirecional, sou uma galinha algorítmica, então registre notas e ideias

Defina uma estrutura de dados de lista encadeada individualmente:

/**
 * 定义一个单链表
 */
public class Node {
	private int data;   //当前节点数据
	private Node next;  //下一个节点

	public Node (int data) {
		this.data = data;
	}

	public int getData () {
		return data;
	}

	public void setData (int data) {
		this.data = data;
	}

	public Node getNext () {
		return next;
	}

	public void setNext (Node next) {
		this.next = next;
	}
}

Aqui, um nó temporário é usado para inverter

	public static Node Reverse2 (Node head){
		//head为当前节点
        Node preNode = null; //preNode为前一个节点
        Node tempNode = null;    //临时节点
        //1、当前节点不为空则进行翻转
        while(head!=null){
            //2、把当前节点head的下一节点数据保存到临时节点中tempNode中，防止丢失
            tempNode = head.getNext();
            //3、把当前节点head的下一节点设置为前一个节点
            head.setNext(preNode);
            //4、把当前节点head赋值给前一节点
            preNode = head;
            //5、把临时节点的数据放到当前节点中
            head = tempNode; 
        }

	}

O princípio é usar um nó temporário para salvar os dados do próximo nó e atribuir os dados do nó temporário ao nó atual após o nó atual apontar para o nó anterior

Analise as alterações de dados nas 5 etapas desta nota: Lista encadeada unidirecional 1—>2—>3—>4—>5

Primeira volta:

Nota 1, ele julgará se a cabeça está vazia, se não estiver vazia, entre no loop, obviamente a cabeça é 1—>2—>3—>4—>5

Nota 2, head.getNext() será armazenado no nó temporário tempNode (variável temporária). Neste momento, tempNode = head.getNext() = 2—>3—>4—>5

Nota 3, o próximo ponto do nó atual apontará para o nó anterior head.setNext(preNode) Neste momento, o valor inicial de preNode é nulo. Portanto, a cabeça atual é 1—>nulo

Nota 4, o nó atual será atribuído ao nó anterior preNode=head, neste momento o valor de preNode é: 1—>null

Nota 5, os dados do nó temporário serão atribuídos ao nó atual, que é head = tempNode = 2—>3—>4—>5. O primeiro ciclo termina

Segunda volta:

Nota 1, para determinar se o cabeçote está vazio, após o final do primeiro ciclo, os dados do cabeçote tornam-se 2—>3—>4—>5. não está vazio, continue a entrar no loop

Nota 2, armazene head.getNext() em tempNode temporário e único, então tempNode = head.getNdext() = 3—>4—>5

Nota 3, aponte o próximo nó atual para o nó anterior. Após o primeiro ciclo, o valor de preNode é 1—>nulo, então a cabeça é 2—>1—>nulo

Nota 4, atribua o nó atual ao nó anterior. Neste momento, o valor de preNode é: 2—>1—>null

Nota 5, atribua o valor da variável temporária ao nó atual, então o valor de head se tornará 3—>4—>5. fim do segundo loop

O terceiro ciclo. . . Quarto ciclo. . Até o final do loop, preNode se tornará 5—>4—>3—>3—>1