反转单向链表和反转双向链表

【题目】

分别实现反转单向链表和反转双向链表的函数

【要求】

如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为O(1)

# -*- coding:utf-8 -*-

# 反转单向链表
# 定义节点结构：指针域pre、next和数据域data
class Node(object):
    def __init__(self, data=None):
        self.data = data
        self.pre = None
        self.next = None


# 循环的方法，使用pre指向前一个节点，cur指向当前节点，每次把cur->next指向pre即可
def reverseList(head):
    if head is None or head.next is None:
        return head
    pre = None
    cur = head
    h = head
    while cur:
        h = cur
        tmp = cur.next
        cur.next = pre
        pre = cur
        cur = tmp
    return h


#递归，head为原链表的头结点，newhead为反转后链表的头结点
def recurse(head, newhead):
    if head is None:
        return
    if head.next is None:
        newhead = head
    else:
        newhead = recurse(head.next, newhead)
        head.next.next = head
        head.next = None
    return newhead


# 初始化双向链表并反转
class DoublyLinkedList(object):
    def __init__(self):
        """
        设置头尾，操作比较容易
        头－－（next）－－>尾
        尾－－（pre）－－>头
        """
        head = Node()
        tail = Node()
        self.head = head
        self.tail = tail
        self.head.next = self.tail
        self.tail.pre = self.head


    """追加节点"""
    def append(self, data):
        """
        :param data:
        :return:
        """
        node = Node(data)
        pre = self.tail.pre
        pre.next = node
        node.pre = pre
        self.tail.pre = node
        node.next = self.tail
        return node

    """反转链表"""
    def __reversed__(self):
        """
        1.node.next --> node.pre
          node.pre --> node.next
        2.head.next --> None
          tail.pre --> None
        3.head-->tail
         tail-->head
        :return:
        """
        pre_head = self.head
        tail = self.tail

        def reverse(pre_node, node):
            if node:
                next_node = node.next
                node.next = pre_node
                pre_node.pre = node
                if pre_node is self.head:
                    pre_node.next = None
                if node is self.tail:
                    node.pre = None
                return reverse(node, next_node)
            else:
                self.head = tail
                self.tail = pre_head

        return reverse(self.head, self.head.next)

    def show(self, order=1):
        if order >= 0:
            node = self.head.next
            while node is not self.tail:
                print(node.data, end=" ")
                node = node.next
        else:
            node = self.tail.pre
            while node is not self.head:
                print(node.data, end=" ")
                node = node.pre
        print()



if __name__ in "__main__":
    # 测试反转单链表，循环的方式
    head = Node(1)  #测试代码
    p1 = Node(2)   #建立链表1->2->3->4->None;
    p2 = Node(3)
    p3 = Node(4)
    head.next = p1
    p1.next = p2
    p2.next = p3
    p = reverseList(head)  #输出链表 4->3->2->1->None
    while p:
        print(p.data)
        p = p.next

    # 测试反转单链表，递归的方式
    head = Node(1)  # 测试代码
    p1 = Node(2)  # 建立链表1->2->3->4->None
    p2 = Node(3)
    p3 = Node(4)
    head.next = p1
    p1.next = p2
    p2.next = p3
    newhead = None
    p = recurse(head, newhead)  # 输出链表4->3->2->1->None
    while p:
        print(p.data)
        p = p.next

    # 测试反转双向链表
    ls = DoublyLinkedList()
    ls.append(1)
    ls.append(2)
    ls.append(3)
    ls.append(4)
    ls.show(1)
    reversed(ls)
    ls.show(1)