指针结构体：

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

迭代法：分三种，分别为头插法，新建链表法，直接反转法

1. 头插法:(插入的节点为prev->next)

ListNode* reverseList(ListNode* head) {
    
        if(!head)return nullptr;
		ListNode* dummy=new ListNode(-1);
		dummy->next=head;
		ListNode* prev=head;
        ListNode* pcur=nullptr;
		while(prev->next){
    
			pcur=prev->next;
            prev->next=pcur->next;
            pcur->next=dummy->next;
            dummy->next=pcur;
		}
		return dummy->next;
    }

2. 新建链表法(每次插入的节点为pcur)

ListNode* reverseList(ListNode* head{
    
	if(!head)return nullptr;
	ListNode* dummy=new ListNode(-1);
	ListNode* pcur=head;
	ListNode* pnext=nullptr;
	while(pcur){
    
		pnext=pcur->next;
		pcur->next=dummy->next;
		dummy->next=pcur;
		pcur=pnext;
	}
    return dummy->next;
}

2. 直接反转法(每次插入的节点为pcur)

ListNode* reverseList(ListNode* head){
    
	ListNode* pcur=head;
	ListNode* prev=nullptr;
	while(pcur){
    
		ListNode* next=pcur->next;
		pcur->next=prev;
		prev=pcur;
		pcur=next;
	}
	return prev;
}

递归法

ListNode* reverseList(ListNode* head){
    
	if(!head||!head->next)return head;//递归出口
	ListNode* new_head=reverseList(head->next);
	head->next->next=head;//关键代码，这里得值得好好想想，此时的head->next之后的节点都是经过反转了的
	head->next=nullptr;
	return new_head;
}

关于 head->next->next=head代码解释：
head之后的节点都是经过反转了的，这句话理解好就行了
1 -> 2 -> 3 -> 4 -> … -> k -> k+1 <- k+2 <- … <- n
当我们要处理第k个节点时，k是指向k+1的，k+1是指向nullptr的，但是我们想k+1指向k，即k+1->next=k即可，此时k+1=k->next,将k+1代换过后的式子为k->next->next=k
经过处理后：
1 -> 2 -> 3 -> 4 -> … -> k <- k+1 <- k+2 <- … <- n
不要忘记将k的指向置空哦k->next=nullptr