算法-反转部分单向链表

思路：
1） 先判断 0<m<=n <= size,不满足直接返回原来的 头节点
2） 先找到 m的前一个节点 m_pre 和 n的后一个节点 n_pos. 把反转的部分反转之后。连接m_pre 和 n_pos.
3) 如果m_pre为null，说明反转的部分包含 头结点，则返回新的头结点，也就是 n. 如果m_pre不为null,则返回旧的头结点。

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head ListNode类 
# @param m int整型 
# @param n int整型 
# @return ListNode类
#
class Solution:
    def reverseBetween(self , head: ListNode, m: int, n: int) -> ListNode:
        # write code here
        if m <0 or m>n or n >1000:
            return head 
        
        current_len = 0  # 当前位置  
        node = head 
        m_pre = None
        n_pos = None 
        while node is not None:
            current_len += 1
            if current_len == m-1:
                # 判断当前 节点是不是 m_pre节点
                m_pre = node

            if current_len == n + 1:
                # 判断当前节点 是不是 n_pre节点
                n_pos = node 
                break
            node = node.next

        # 用node变量保存开始反转的节点。
        if m_pre is None:
            # 如果m_pre 是 None，说明 m是头结点，
            node = head 
        else:
            # m_pre不是None, m不是头节点 ,开始反转的节点是m_pre.next 
            node = m_pre.next 
            
        # node 是 循环的前一个节点 变量
        # node2 是当前节点
        # next 是当前节点的下一个节点， 每次循环更新这三个变量
        
        # 从下一个节点开始，node是前一个节点。
        node2 = node.next  # 3 。
        
        node.next = n_pos # 开始反转的节点的下一个 节点连接 n_pos ， 2 > 5 
        
        next = None # next变量 
        
        while node2 != n_pos:
            # 遍历到 n_pos节点
            next = node2.next # 保存当前node的next 
            node2.next = node  # 将当前节点的下一个改为 前一个节点。
            
            node = node2 # 当前节点 更新为 前一个节点 
            node2 = next # 更新当前节点 
        
        if m_pre is not None:
            # 不是 从头节点开始。 返回原来的头节点 head . 把 1 > 4 
            m_pre.next = node # 反转结束后。 node已经变成 4 了。
            return head 
        return node