Python之链表

定义

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。

每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

Python中的实例

# 定义单节点
 class ListNode(object):
     def __init__(self, x):
         self.val = x
         self.next = None

在新建头结点时：

head = ListNode(0) #值为0

leetcode的应用

142. Linked List Cycle II

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None


# 方法一、把遍历的指针都保存起来，如果有重复就返回重复节点，没有重复，链表到底了就返回None
class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """

        cur = head
        dict = {}
        i = 0

        while cur:
            dict[cur] = i
            cur = cur.next
            if cur in dict:
                return cur
            i += 1

        return None

# 方法二、快慢指针，两个不同遍历速度的指针，如果指针重合了，说明有重复，然后再循环找出第一个重复的节点（需要数学证明）
class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """

        slow = fast = head

        while fast and fast.next and slow:  # 如果不符合判断条件，则无环，返回None
            slow = slow.next
            fast = fast.next.next
            if slow == fast:   #有环，打断进入下一个循环
                break
        else:
            return None

        temp = head
        while 1:   # 复制一个头节点，再重新走到重合
            if temp == slow:
                return temp
            temp = temp.next
            slow = slow.next

• 结果：
  1. 方法一、
     
  2. 方法二、
     

206. Reverse Linked List

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

# 方法一、循环反转
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """

        if head == None:
            return None

        cur_0 = head
        temp = cur_1 = head.next

        head.next = None

        while temp:
            temp = cur_1.next
            cur_1.next = cur_0
            cur_0 = cur_1
            cur_1 = temp

        return cur_0

# 方法一的改进
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """

        cur = head
        pre = None
        fro = None
        head_Node = head

        while cur:   # 设置三个节点的变量，不断变换
            fro = cur.next
            if fro == None:
                head_Node = cur
            cur.next = pre
            pre = cur
            cur = fro

        return head_Node

# 方法二：递归

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        head_node = head

        if head != None and head.next != None:  #左边条件时为了避免链表为空，head=none的情况

            head_node = cur = self.reverseList(head.next)

            while cur.next:
                cur = cur.next

            cur.next = head
            head.next = None

        return head_node

• 结果：（按上述方法顺序排列）
  1.
  
  2.
  
  3.