LeetCode—206 反转链表 Cpp&Python

题目要求：传入链表头指针，进行链表反转

过程如下：
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

一、方法与思路

方法一：迭代法
在对链表进行遍历的过程中，使得当前节点指向前一节点。此外，还需要另一个指针来存储下一个节点，最终返回新的头节点。
过程如下

在进行遍历时，完成三个步骤：
Step1:
当前节点指向前一节点new_head
Step2:
new_head移动到head的位置
Step3:
head移动到下一位置，此过程中就需要引入next节点保存位置信息完成操作

---

方法二:递归法
递归的思路就是先递归到底, 找到最后一个节点, 然后从最后一个节点开始, 把箭头方向掉转。
标记文本
递归结束条件：

if(head == NULL || head->next == NULL) 
    return head;

得到最后一个节点之后, 返回给上一层递归, p指向原链表的最后一个节点, 现在要作为头节点, 之后的p都不需要改动, 不断返回给上一层递归

改变head的next的指向, 让它指向自己,再把head的next指向空, 作为新链表的最后一个节点

head->next->next = head;
head->next = NULL;

递归结束, 最后返回的还是p(头节点)

二、C++代码

#include <stdio.h>

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

class Solution {
public:
	ListNode* ReverseTheList1(ListNode* head){//迭代法
		ListNode *new_head = NULL;
		while (head)  //进行遍历
		{
			ListNode *next = head->next;
			head->next = new_head;
			new_head = head;
			head = next;
		}
		return new_head;
	}
	ListNode* ReverseTheList2(ListNode* head) {//递归法
		if (head == NULL || head->next == NULL)
			return head;

		ListNode* p = ReverseTheList2(head->next);
		head->next->next = head;
		head->next = NULL;
		return p;
	}
	
};
	int main() {//测试用例
		ListNode a1(1);ListNode b1(2);ListNode c1(3);ListNode d1(4);ListNode e1(5);
		a1.next = &b1; b1.next = &c1; c1.next = &d1; d1.next = &e1;
		ListNode a2(1); ListNode b2(2); ListNode c2(3); ListNode d2(4); ListNode e2(5);
		a2.next = &b2; b2.next = &c2; c2.next = &d2; d2.next = &e2;
		Solution solve;
		ListNode *head1 = solve.ReverseTheList1(&a1);
		ListNode *head2 = solve.ReverseTheList2(&a2);
		while (head1){
			printf("%d\n", head1->val);
			head1 = head1->next;
		}
		printf("------------\n");
		while (head2) {
			printf("%d\n", head2->val);
			head2 = head2->next;
		}
		return 0;
	}
	//Time:O(n) Sapce:O(1)

---

三、Python代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
	#迭代法
    def reverseList1(self, head: ListNode) -> ListNode:
        pre, cur = None, head
        while cur:
            temp = cur.next
            cur.next = pre
            pre, cur = cur, temp
        return pre

	#递归法
     def reverseList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        newhead = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return newhead