这周一道算法题(六十八)

本周题目难度'Medium',使用语言'Python'.这周做题皮了下，要不估计没那么快做出来。。。

题目：给你一个链表head,让你将m~n这一段反转，其中1 ≤ m ≤ n ≤ 链表长度，要求只能遍历一次链表。eg: 1->2->3->4->5->NULL, m = 2, n = 4；返回的结果是1->4->3->2->5->NULL

思路：我皮了一下，先把链表遍历到m处，然后把从m到n这一段放到一个数组里，然后倒序遍历一下，任务就完成了，看代码吧：

class Solution:
    def reverseBetween(self, head, m, n):
        """
        :type head: ListNode
        :type m: int
        :type n: int
        :rtype: ListNode
        """
        # 将m～n这一段节点放入数组
        def Traversing(node, n):
            arr = []
            while n:
                arr.append(node)
                node = node.next
                n -= 1
            return [arr, node]
        # 如果m==n，直接返回原数组即可
        if m == n: return head
        # 定义个节点
        newHead = head
        # if～else是将m～n的一段节点放入数组里
        if m == 1:
            arr_all = Traversing(head, n)
            head = arr_all[0][-1]
        else:
            while m-2:
                newHead = newHead.next
                m -= 1
                n -= 1
            temp = newHead.next
            arr_all = Traversing(temp, n-1)
        # 倒序遍历数组，将节点拼装返回即可
        for i in reversed(arr_all[0]):
            newHead.next = i
            newHead = newHead.next
        newHead.next = arr_all[1]
        return head

本来效率是挺高的，但代码比较长，然后优化精简了下代码，效率就变的一般了，反正这个思路也是投机取巧的，看下高质量代码吧：

class Solution:
    def reverseBetween(self, head, m, n):
        """
        :type head: ListNode
        :type m: int
        :type n: int
        :rtype: ListNode
        """
        if m==n or head.next is None: return head
        dummy = ListNode(None)
        dummy.next = head
        b1 = dummy
        for _ in range(m-1):
            b1 = b1.next
        p = b1.next
        nh = p
        tmp = p.next
        for _ in range(n-m):
            nt = tmp
            tmp = nt.next
            nt.next = p
            p = nt
        b1.next = nt
        nh.next = tmp
        return dummy.next

就不注释了，大家自己看看就好。。。

版权声明：本文为 Crazy Steven 原创出品，欢迎转载，转载时请注明出处!