链表结构
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
leetcode 206 单链表反转——（考察指针）
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
思路：
迭代
设置两个指针（new_head和next），new_head始终使其指向新链表的头结点，next始终使其指向待反转链表的头结点。
步骤图示如下（渣绘）
代码如下：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if((head==nullptr)||(head->next==nullptr))
return head;
ListNode * new_head=nullptr,*next=nullptr;
while(head){
//next指向待排序链表的头结点
next=head->next;
//令被拆下来的节点的next指针指向新链表的头结点
head->next=new_head;
//移动new_head，使其保持指向新链表的头结点
new_head=head;
//使head指向待排序链表的头结点
head=next;
}
return new_head;
}
};递归
递归着将链表层层拆解，等遇到尾节点时，将其设置为链表的头结点，之后层层从递归中返回，将之前记录的节点设置为当前链表的尾节点。类似下图（渣绘，求原谅）：
代码如下：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* helper(ListNode* head){
ListNode* current_head=nullptr;
ListNode* head_next=nullptr;
if ((head == NULL)||(head->next == NULL)){
return head;
}else{
//记下当前的头结点a0
current_head = head;
//记下当前头结点后面的结点a1
head_next = head->next;
//返回(a1...an)逆转后的头结点
head = helper(head_next);
//用上面保存的地址（逆转后的尾结点）指向原来的头结点a0
head_next->next = current_head;
//将a0的next域置零
current_head->next = NULL;
}
//返回a0
return head;
}
ListNode* reverseList(ListNode* head) {
if((head==nullptr)||(head->next==nullptr))
return head;
ListNode * tail=nullptr;
tail=helper(head);
return tail;
}
};
链表结构
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
leetcode 206 单链表反转——（考察指针）
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
思路：
迭代
设置两个指针（new_head和next），new_head始终使其指向新链表的头结点，next始终使其指向待反转链表的头结点。
步骤图示如下（渣绘）
代码如下：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
if((head==nullptr)||(head->next==nullptr))
return head;
ListNode * new_head=nullptr,*next=nullptr;
while(head){
//next指向待排序链表的头结点
next=head->next;
//令被拆下来的节点的next指针指向新链表的头结点
head->next=new_head;
//移动new_head，使其保持指向新链表的头结点
new_head=head;
//使head指向待排序链表的头结点
head=next;
}
return new_head;
}
};递归
递归着将链表层层拆解，等遇到尾节点时，将其设置为链表的头结点，之后层层从递归中返回，将之前记录的节点设置为当前链表的尾节点。类似下图（渣绘，求原谅）：
代码如下：
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* helper(ListNode* head){
ListNode* current_head=nullptr;
ListNode* head_next=nullptr;
if ((head == NULL)||(head->next == NULL)){
return head;
}else{
//记下当前的头结点a0
current_head = head;
//记下当前头结点后面的结点a1
head_next = head->next;
//返回(a1...an)逆转后的头结点
head = helper(head_next);
//用上面保存的地址（逆转后的尾结点）指向原来的头结点a0
head_next->next = current_head;
//将a0的next域置零
current_head->next = NULL;
}
//返回a0
return head;
}
ListNode* reverseList(ListNode* head) {
if((head==nullptr)||(head->next==nullptr))
return head;
ListNode * tail=nullptr;
tail=helper(head);
return tail;
}
};