递归实现链表快速倒转（python）

一.题目要求

给定一个链表，请对该链表实现反转。倒转之前的链表为：1—>2—>3—>4—>5
倒转之后的链表为：5—>4—>3—>2—>1

二，结题思路

本文采用了一种递归的思想：如果要倒转的链表有n个节点，那么如果第一个节点后面的n-1个节点已经正确倒转了的话，只要处理第一个和第二个节点的指向关系就可以了。要使后面n-1个节点正确倒转，那么闲要使得后面的n-2个节点正确倒转。于是接这么递归下去。最后只剩一个节点的时候，就什么都不用做了，只需要改变其与原来的上一个节点之间的关系就可以了。

三.代码实现

首先，创建一个长度可以自己定义的链表：

# 创建节点类 val代表节点中的值，next代表下一个节点
class Node:
    def __init__(self,val):
        self.next = None
        self.val = val

class ListUtility:
    def __init__(self):
        self.head = None
        self.tail = None
        pass

    def createList(self,nodeNum):
        #生成含有nodeNum个节点的列表
        if nodeNum<=0:
            return None
        head = None
        val = 0
        node = None

        # 构造给定节点的队列，每个节点数值一次递增
        while nodeNum>0:
            '''
            如果head指针为空，代码先构造队列头部；如果不为空，代码构造节点对象。
            然后用上一个节点的next指针指向当前节点，从而将多个节点串联形成队列
            '''
            if head is None:
                head = Node(val)
                node = head
            else:
                node.next = Node(val)
                node = node.next
                self.tail = node
            val+=1
            nodeNum-=1
        self.head = head
        return head

    def printList(self,head):
        '''
        根据队列头节点，依次遍历队列每个节点对象，并打印出节点值
        假设队列含有3个节点，节点的值分别是1,2,3，那么代码输出结果为：
        1——》2——》3--》null
        '''
        while head is not None:
            print("{}-->".format(head.val),end = '')
            head = head.next
        print("null")

其中，Node用来表示链表节点；ListUtility的作用是生成一个用于操作的链表，同时当给定链表头节点时，把链表打印出来。真正实现链表倒转作用的是如下代码：

class ListReverse:
    def __init__(self,head):
        self.listHead = head
        self.newHead = None
    def recursiveReverse(self,node):
        # 如果队列为空或者只有一个节点，那么队列已经倒转成
        if node is None or node.next is None:
            self.newHead = node
            return node

        '''
        如果队列包含多个节点，那么通过递归调用的方法，
        先把当前节点之后所有节点实现倒转，
        然后再把当前节点之后节点的next指针指向自己，从而完成整个列表所有节点的倒转
        '''
        head = self.recursiveReverse(node.next)
        head.next = node
        node.next = None
        return node

    def getReverseList(self):
        '''
        listHead是原队列的头节点，执行recursiveReverse后newHead指向
        新列表的头结点，它对应的其实是原列表的为节点
        而head指向新列表的尾节点
        '''
        self.recursiveReverse(self.listHead)
        return self.newHead

recursiveReverse做的就是递归性地倒转链表，如果当前只有一个节点，那么链表就已经倒转完毕；如果不止一个节点，那么先把当前节点后面的链表倒转，然后改变当前节点的下一个节点的指向关系，原来是当前节点的next指针指向下一个节点，现在改成下一个节点的next指针指向当前节点。
我们先创建一个含有7个节点的链表，然后调用上面的代码进行倒转，看看运行结果。

if __name__ == '__main__':
    utility = ListUtility()
    head = utility.createList(7)
    utility.printList(head)
    # 执行倒转算法，然后再打印队列，前后对比看看倒转是否成功
    reverse = ListReverse(head)
    utility.printList(reverse.getReverseList())

运行结果如下：

0-->1-->2-->3-->4-->5-->6-->null
6-->5-->4-->3-->2-->1-->0-->null
Process finished with exit code 0

从运行结果可知，我们的算法设计是正确的