单链表的反转--四种方法总结

单链表的反转–四种方法总结

创建单链表

代码和原理

#(1)创建节点
class ListNode:
    def __init__(self,x):
        self.val = x
        self.next = None

#(2)初始化单链表
class LinkList:
    def __init__(self):
        self.head=None

    def initList(self, data): #初始化单链表
        #创建头结点
        self.head = ListNode(data[0])
        r = self.head
        p = self.head
        # 逐个为data内的数据创建节点，建立链表
        for i in data[1:]:
            node = ListNode(i)
            p.next = node
            p = p.next
        return r
    def printlist(self,head): #遍历单链表
        if head == None: return
        node = head
        while node != None:
            print(node.val, end= ' ')
            node = node.next

反转单链表

方法一 生成新链表

（1）将链表里的值保存到列表，

（2）遍历列表，生成节点加入到新链表中，时间空间复杂度都为O(n)

def reverseLinkedList1(head):
        # arrayList = []
        # while head:
        #     arrayList.append(head.val)
        #     head = head.next
        # # ArrayList.reverse()  # 列表的反转功能
        # newHead = head(0)
        # tmp = newHead
        # for i in arrayList[::-1]:  # 反向遍历列表
        #     tmp.next = head(i)
        #     tmp = tmp.next
        # return newHead.next
        arrayList = []
        head = head
        while head:
            arrayList.insert(0, head.val) #插入
            head = head.next
        newHead = ListNode(0) #生成第一个新节点
        tmp = newHead
        for i in arrayList:
            tmp.next = ListNode(i)
            tmp = tmp.next
        return newHead.next

https://zhuanlan.zhihu.com/p/66449047
https://www.cnblogs.com/petrolero/p/9822008.html

方法二 双指针法–第一个节点为循环变量curr

（1）先初始化newNode = nextNode = None, curr=head

（2）curr.next保存到nextNode节点，curr.next指向newNode实现反转，newNode和currNode后移，准备下个节点反转

def reverseLinkedList2(self, head):
        if head == None or head.next == None:
            return head
        newHead = None #新链表的表头
        currNode = head #当前节点
        nextNode = None #保存当前节点的下一个节点
        while currNode:
            nextNode = currNode.next
            currNode.next = newHead
            newHead = currNode
            currNode = nextNode
        return newHead

方法三 双指针法–第二个节点为循环变量p2

（1）初始化tmpNode=None，p1 = head , p2=head.next

（2）tmp保存p2的next节点，p2.next指向p1实现反转，p1和p2往后移动，准备下一个节点反转

（3）++最后特别注意++：将原来头结点指针置空（head.next = None）

def reverseLinkedList3(self, head):
        if head == None or head.next == None:  # 边界条件
            return head
        p1 = head  # 循环变量1
        p2 = head.next  # 循环变量2
        tmp = None  # 保存数据的临时变量
        while p2:
            tmp = p2.next
            p2.next = p1
            p1 = p2
            p2 = tmp
        head.next = None #将原来头结点指针置空
        return p1

方法四 递归法

（1）递归反转单链表，直到heap.next.next==Node

（2）heap.next.next=heap实现反转，然后置空heap.next

（3）往前pop，直到全部栈里的节点出来

def reverseLinkedList4(self, head):
        if head == None or head.next == None:  # 边界条件
            return head
        else:
            newHead = reverseLinkedList4(head.next)
            head.next.next = head
            head.next = None
        return newHead