Tema: Ingrese una lista vinculada, después de invertir la lista vinculada, genere el encabezado de la nueva lista vinculada.
Resumen de reflexión: tenga en cuenta que si pHead es una tabla vacía, entonces Phead-> next no existe, ¡así que tenga cuidado! ! !
/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
ListNode* ReverseList(ListNode* pHead) {
ListNode* L=nullptr; //运用前插法
//在这里玩意PHead是空的情况下，那么就没有pHead->next存在！！！注意！！！
ListNode* p=pHead;
ListNode* q;
while(p!=nullptr)
{
q=p->next;
p->next=L;
L=p;
p=q;
}
return L;
}
};
En la segunda pregunta, un conjunto de k listas enlazadas invertidas, y el resto menos que k permanece igual.
(1) Utilice el método de preinterpolación
Voltea cada grupo de nodos en la lista vinculada dada \ kk, y devuelve la lista vinculada invertida.
Si el número de nodos en la lista vinculada no es un múltiplo de \ kk, mantén los últimos nodos restantes como están.
No puedes cambiar el valores en los nodos, solo se puede cambiar el nodo en sí.
Requiere complejidad de espacio \ O (1) O (1)
Por ejemplo:
la lista vinculada dada es 1 → 2 → 3 → 4 → 5
Para k = 2, debe devolver 2 → 1 → 4 → 3 → 5
para k = 3 , Debe devolver 3 → 2 → 1 → 4 → 5
1. La idea de esta pregunta: primero observe si hay al menos k nodos comenzando desde el p actual Recuerde guardar la posición del puntero original antes del bucle para que pueda ser restaurado en ese momento.
2. Luego recuerde guardar el último nodo después de cada k volteos (es decir, el primer nodo en el k original, que se puede vincular a la siguiente lista de k vinculados oa los vínculos restantes la próxima vez).
3. El general no es difícil, pero recuerde, cuando p ya es nullptr, ya no puede p-> next, esto es muy fácil de cometer errores.
/**
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
class Solution {
public:
/**
*
* @param head ListNode类
* @param k int整型
* @return ListNode类
*/
ListNode* reverseKGroup(ListNode* head, int k) {
int num=0;
ListNode* L=nullptr;
ListNode* p=head;
ListNode* q;
ListNode* tail=nullptr;
ListNode* tailpre=nullptr;
while(p!=nullptr)
{
q=p; //记录初始结点
ListNode * start=p;
num=0;
while(num<k&&p!=nullptr)
{
num++;
p=p->next;
}
if(num==k) //这部分构成一个反置链表
{
p=q;
ListNode *L1=nullptr;
while(num>0&&p!=nullptr)
{
if(num==k)
{
tail=p; //保留当前子链表排好序后最后一个元素。
}
q=p->next;
p->next=L1;
L1=p;
p=q;
num--;
}
if(L==nullptr)
{
L=L1;
}
else
{
tailpre->next=L1;
}
tailpre=tail;
}
else if(num<k)
{
if(tail==nullptr) //整体长度小于k。
{
L=start;
}
else
{
tailpre->next=start; //最后剩余少于k的那部分。
}
}
}
return L;
// write code here
}
};
(2) Usar pila
import java.util.*;
import java.math.*;
/*
* public class ListNode {
* int val;
* ListNode next = null;
* }
*/
public class Solution {
/**
*
* @param head ListNode类
* @param k int整型
* @return ListNode类
*/
public ListNode reverseKGroup (ListNode head, int k) {
// write code here
Stack<ListNode> stack=new Stack<ListNode>();
ListNode ret=new ListNode(0);
ListNode p=ret;
ListNode temp;
while(true)
{
int num=0;
temp=head;
while(num<k&&temp!=null)
{
stack.push(temp);
num++;
temp=temp.next;
}
if(num<k)
{
p.next=head;
break;
}
else if(num==k)
{
while(!stack.isEmpty())
{
p.next=stack.pop();
p=p.next;
}
}
p.next=temp;
head=temp;
}
return ret.next;
}
}