数据结构与算法之链表: LeetCode 206. 反转链表 (Ts, Py, Go版)_typescript给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。-优快云博客

反转链表

https://leetcode.cn/problems/reverse-linked-list/

描述

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2

输入：head = [1,2]
输出：[2,1]

示例 3

输入：head = []
输出：[]

提示

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

Typescript 版算法实现

1 ）方案 1

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

function reverseList(head: ListNode | null): ListNode | null {
    let p1 = head; //  p1 = 1
    let p2 = null;
    while(p1) {
        // console.log(p1 && p1.val, p2 && p2.val);
        const tmp = p1.next; // 暂存下一个节点，比如当前节点的值是1的节点下个节点的值是2的节点
        p1.next = p2; // 将p1的next指向p2，一开始p1=1,p2=null, 不断把p1的next指回给p2
        p2 = p1; // p2赋值 p2 = 1 这里完成p2和p1的交换
        p1 = tmp; // p1赋值成下一个值 p1 = 2 这里完成把p1.next赋值给p1
    }
    /*
    // while中，p1, p2的循环输出，可见不断交换p1, p2的值
    1, null
    2, 1
    3, 2
    4, 3
    5, 4
    null, 5
    // 在while循环最后，p1指向null, p2指向5
    */
    console.log(p1 && p1.val, p2 && p2.val); // 最终p1指向null， p2指向5
    return p2;
};

解题思路
- 先反转两个节点：将n+1的next指向n
- 反转多个节点：双指针遍历链表，重复上述操作
解题步骤
- 输入：双指针一前一后遍历链表
- 输出：反转双指针

2 ）方案2

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

function reverseList(head: ListNode | null): ListNode | null {
    let result: ListNode | null  = null;
    while(head){
        const temp = head.next; // 存储当前的下一个Node
        head.next = result; // 当前的Next指向给临时的结果
        result = head; // 将当前指向给结果
        head = temp; // 将当前的一下Node指向给当前
    }
    return result;
};

这是官方示例程序，就是变量名换了一下和方案1是一致的实现
实际上，官方示例的变量定义更好，对程序员更友好

Python3 版算法实现

1 ) 方案1

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p1 = head
        p2 = None
        while p1:
            tmp = p1.next
            p1.next = p2
            p2 = p1
            p1 = tmp
        return p2

2 ) 方案2

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        result = None
        while head:
            temp = head.next  # 存储当前的下一个节点
            head.next = result  # 当前的下一个节点指向给定的结果
            result = head  # 将当前节点指向给结果
            head = temp  # 将当前的下一个节点指向给当前节点
        return result

Golang 版算法实现

1 ) 方案1

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
	var p1, p2 *ListNode = head, nil
	for p1 != nil {
		tmp := p1.Next
		p1.Next = p2
		p2 = p1
		p1 = tmp
	}
	return p2
}

2 ) 方案2

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reverseList(head *ListNode) *ListNode {
	var result *ListNode = nil
	for head != nil {
		temp := head.Next // 存储当前的下一个节点
		head.Next = result // 当前的下一个节点指向给定的结果
		result = head // 将当前节点指向给结果
		head = temp // 将当前的下一个节点指向给当前节点
	}
	return result
}