六、链表

1. 使用python定义链表结构

from util.Empty import Empty
from util.Outbound import Outbound

class Node():
    def __init__ (self, value = None, next = None):
        self.value = value
        self.next = next

class LinkedList():
    def __init__(self):
        self.head = Node()
        self.tail = None
        self.length = 0

    def peek(self):
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        return self.head.next

    def get_first(self): # 得到第一个元素 
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        return self.head.next
        
    def get_last(self): # 得到最后一个元素
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        node = self.head
        while node.next != None:
            node = node.next
        return node
    
    def get(self, index): # 按索引得到元素 
        if (index < 0 or index >= self.length):
            raise Outbound( 'index is out of bound' );
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        node = self.head.next
        for i in range(index):
            node = node.next
        return node
                
    def add_first(self, value):
        node = Node(value, None)
        node.next = self.head.next
        self.head.next = node
        self.length += 1   
        
    def add_last(self, value):
        new_node = Node(value)
        node = self.head
        while node.next != None:
            node = node.next
        node.next = new_node
        self.length += 1

    def add(self, index, value):
        if (index < 0 or index > self.length):
            raise Outbound( 'index is out of bound' )
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        new_node = Node(value)
        node = self.head
        for i in range(index):
            node = node.next
        new_node.next = node.next;
        node.next = new_node;
        self.length += 1     
        
    def remove_first(self):
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        value = self.head.next
        self.head.next = self.head.next.next
        self.length -= 1
        return value    
        
    def remove_last(self):
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        node = self.head.next
        prev = self.head
        while node.next != None:
            prev = node
            node = node.next
        prev.next = None
        return node.value

    def remove(self, index):
        if (index < 0 or index >= self.length):
            raise Outbound( 'index is out of bound' );
        if not self.head.next:
            raise Empty( 'LinkedList is empty' )
        node = self.head
        for i in range(index):
            node = node.next
        result = node.next;
        node.next = node.next.next;
        self.length += 1     
        return result;      
        
    def printlist(self):
        node = self.head.next
        count = 0
        while node and count<20:
            print(node.value, end = " ")
            node = node.next
            count = count + 1
        print('')

2. 删除链表中的节点 

• leetcode: 第237题. 删除链表中的节点，只允许访问要删除的那个节点。 难度：简单
• leetcode: 面试题18. 删除链表的节点 与此题要求不一样，有可能包括尾节点也要删除

# 传统的方法是找到prev节点，然后让prev.next = prev.next.next 
# 现在不让访问prev了，只允许访问当前的node
def delete_node(node):  
    print(node.value)  
    node.value = node.next.value    # 偷梁换柱，把下一个节点的value赋值给当前节点的值，删除下一个节点即可。
    node.next = node.next.next

3. 找到链表的中间节点

• leetcode 第876题. 链表的中间结点 难度：简单

# 快慢指针思想
def find_middle(lst):
    assert lst.head is not None and lst.head.next is not None
    
    head = lst.head
    fast = head
    slow = head
    
    while fast is not None and fast.next is not None:
        fast = fast.next.next
        slow = slow.next
    
    return slow.value

4. 确定链表是不是环形的

• leetcode 第141题. 环形链表 难度：简单

  def has_cycle(lst):
      return has_cycle_helper(lst.head)
  
  def has_cycle_helper(head):
      if head is None:
          return False
      
      slow = head 
      fast = head 
      
      while fast is not None and fast.next is not None:
          fast = fast.next.next
          slow = slow.next
          
          if slow == fast:  # 环形的赛道一定会相遇
              return True
          
      return False

5.  给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

• leetcode 第142题. 环形链表 II 难度：中等
• 面试题 02.08. 环路检测 难度：中等

def find_beginning(head): 
    fast = head 
    slow = head 
    meet = None 
    while fast and fast.next is not None:
        fast = fast.next.next 
        slow = slow.next 

        if fast == slow:
            meet = fast 
            break 

    if meet is None or meet.next is None:
        return None 

    while head and meet:
        if head == meet:
            return meet 
        head = head.next
        meet = meet.next 

    return None

6.

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

• leetcode 第19题. 删除链表的倒数第N个节点 难度：中等
• 面试题22. 链表中倒数第k个节点 难度：简单
• 面试题 02.02. 返回倒数第 k 个节点 

  def remove_nth(lst, n):
      assert n<=lst.length and n > 0
      
      fast = lst.head
      while n > 0:
          fast = fast.next
          n = n - 1
      
      if fast == None:
          return head 
          
      slow = lst.head
      while fast.next is not None:
          fast = fast.next
          slow = slow.next
          
      result = slow.next
      slow.next = slow.next.next
      
      lst.length = lst.length - 1
          
      return result

7. 把链表从中间切开成两个链表

def split(head):
    if (head is None):
        return
    slow = head
    fast = head
    front_last_node = slow
    while (fast is not None):  # 先找到中间节点
        front_last_node = slow
        slow = slow.next
        fast = fast.next.next if fast.next is not None else None
    front_last_node.next = None
    front = head
    back = slow
    return (front, back)

8. 合并两个有序的链表

• leetcode 第21题. 合并两个有序链表 难度：简单

# iteratively
# O(m + n)
def mergeTwoLists1(l1, l2):
    dummy = cur = Node(0)
    while l1 and l2:
        if l1.value < l2.value:
            cur.next = l1
            l1 = l1.next
        else:
            cur.next = l2 
            l2 = l2.next
        cur = cur.next
    cur.next = l1 or l2
    return dummy.next

9.  找到两个链表的第一个公共节点

A: a1 → a2

                 ↘

                   c1 → c2 → c3

                 ↗    

B: b1 → b2 → b3

def getIntersectionNode(headA, headB):
    curA, curB = headA, headB
    lenA, lenB = 0, 0
    while curA is not None:
        lenA += 1
        curA = curA.next
    while curB is not None:
        lenB += 1
        curB = curB.next
    curA, curB = headA, headB
    if lenA > lenB:
        for i in range(lenA-lenB):
            curA = curA.next
    elif lenB > lenA:
        for i in range(lenB-lenA):
            curB = curB.next
    while curB != curA:
        curB = curB.next
        curA = curA.next
    return curA

10.  插入排序

• leetcode 第147题. 对链表进行插入排序 难度：中等

# O(n^2)
def insertionSortList(head):
    dummy = Node(0)
    cur = head
    # pre is the sorted part
    # when see a new node, start from dummy
    # cur is the unsorted part
    while cur is not None:
        pre = dummy
        while pre.next is not None and pre.next.value < cur.value:
            pre = pre.next
        temp = cur.next # 插入
        cur.next = pre.next
        pre.next = cur
        cur = temp
    return dummy.next

11. 对链表进行排序

• leetcode 第148题. 排序链表 难度：中等

# Merge sort的思想
def sortList(head):
    if head is None or head.next is None:
        return head
    mid = getMiddle(head)
    rHead = mid.next
    mid.next = None
    return merge(sortList(head), sortList(rHead))

def merge(lHead, rHead):
    dummyNode = dummyHead = Node(0)
    while lHead and rHead:
        if lHead.value < rHead.value:
            dummyHead.next = lHead
            lHead = lHead.next
        else:
            dummyHead.next = rHead
            rHead = rHead.next
        dummyHead = dummyHead.next
    if lHead:
        dummyHead.next = lHead
    elif rHead:
        dummyHead.next = rHead
    return dummyNode.next

def getMiddle(head):
    if head is None:
        return head
    slow = head
    fast = head
    while fast.next and fast.next.next:
        slow = slow.next
        fast = fast.next.next
    return slow　

　12. 分隔链表

给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。

你应当保留两个分区中每个节点的初始相对位置。

• leetcode 第86题. 分隔链表 难度：中等
• 面试题 02.04. 分割链表 难度：中等

def partition(head, x):
    left_head = Node(None)  # head of the list with nodes values < x
    right_head = Node(None)  # head of the list with nodes values >= x
    left = left_head  # attach here nodes with values < x
    right = right_head  # attach here nodes with values >= x
    # traverse the list and attach current node to left or right nodes
    while head:
        if head.value < x:  
            left.next = head
            left = left.next
        else:  # head.val >= x
            right.next = head
            right = right.next
        head = head.next
    right.next = None  # set tail of the right list to None
    left.next = right_head.next  # attach left list to the right
    return left_head.next  # head of a new partitioned list

　13.

• 面试题24. 反转链表
• leetcode 第206题. 反转链表 难度：简单

def reverse(lst):
    head = lst.head # 哨兵节点 
    result = None
    current = head.next 
    nxt = None
    
    while current is not None:
        nxt = current.next  # 事先存储元素
        current.next = result # 指向前一个元素 
        result = current # 赋值给新链表 
        current = nxt 
        
    head.next = result

14. 

• leetcode 第92题. 反转链表 II 难度：中等

def reverseBetween(head, m, n):
    if m == n:
        return head

    dummyNode = Node(0)
    dummyNode.next = head
    pre = dummyNode

    for i in range(m - 1): # 先定位到m位置
        pre = pre.next

    # reverse the [m, n] nodes
    result = None
    current = pre.next # 再使用第一种方法反转
    for i in range(n - m + 1):
        nxt = current.next
        current.next = result
        result = current
        current = nxt

    pre.next.next = current
    pre.next = result

    return dummyNode.next

15. 

• leetcode 第25题. K 个一组翻转链表 难度：困难

def reverseKGroup(head, k):
    if head is None or k < 2:
        return head
    
    next_head = head
    for i in range(k - 1):
        next_head = next_head.next
        if next_head is None:
            return head
    ret = next_head # 先用ret记录住当前第一个反转列表的位置，也是整个反转列表的开头，反转完返回它即可。
    
    current = head
    while next_head:
        tail = current  # 先用tail记录住当前current的位置
        prev = None
        for i in range(k):
            if next_head:
                next_head = next_head.next
            nxt = current.next
            current.next = prev
            prev = current
            current = nxt
        tail.next = next_head or current
    return ret

16. 

• leetcode 第234题. 回文链表 难度：简单
• 面试题 02.06. 回文链表 难度：简单

# 找到中间节点和中间节点的前一个节点
def isPalindrome(head):
    rev = None
    slow = fast = head  
    while fast and fast.next:
        fast = fast.next.next
        rev, rev.next, slow = slow, rev, slow.next
    if fast:
        slow = slow.next
    while rev and rev.value == slow.value:
        slow = slow.next
        rev = rev.next 
    return not rev 

17. 

Given 1->1->2, return 1->2.

Given 1->1->2->3->3, return 1->2->3.

• leetcode 第83题. 删除排序链表中的重复元素 

def deleteDuplicates(head):
    if head == None:
        return head

    node = head

    while node.next:
        if node.value == node.next.value:
            node.next = node.next.next
        else:
            node = node.next

    return head

18. 

Given 1->2->3->3->4->4->5, return 1->2->5.

Given 1->1->1->2->3, return 2->3.

• leetcode 第82题. 删除排序链表中的重复元素 II 难度：中等

def deleteDuplicates2(head):
    dummy = pre = Node(0)
    dummy.next = head
    while head and head.next:
        if head.value == head.next.value:
            while head and head.next and head.value == head.next.value:
                head = head.next
            head = head.next
            pre.next = head
        else:
            pre = pre.next
            head = head.next
    return dummy.next