Python ListNode.ListNode类代码示例

    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        
        if not head:
            return head
        
        # a dummy node is must
        dummy = ListNode(0)
        dummy.next = head
        
        prev = dummy
        current = head
        
        while current:
            
            if current.next and current.val == current.next.val:

                # find duplciate, delete all
                while current.next and current.val == current.next.val:
                    current = current.next
                
                # now current pointer is at last node of duplicated
                # delete duplicated nodes
                prev.next = current.next
                current = current.next
                # @note: prev stays the same
                
            else:
                prev = current
                current = current.next
        
        return dummy.next # return could be a empty list, if input list with all duplicates

def generate_test_list2():
    n1 = ListNode(1)
    n2 = ListNode(2)

    n1.next = n2

    return n1

def rotateLSegment(l, m, n):
    dummyN = ListNode(0)
    dummyN.next = l

    l = dummyN
    rslt, i = l, 0

    while i < m-1:
        l = l.next
        i += 1

    t, i = None, 0

    beg, end = l, l.next
    l = l.next

    while l and i <= n-m:
        h = l
        l = l.next
        h.next = t
        t = h
        i += 1

    beg.next = t
    end.next = l

    return dummyN.next

def test3():
    n1 = ListNode(1)
    n2 = ListNode(2)

    n1.next = n2

    ListNode.print_ll(reorderList(n1))

def revKGroup_r(h, k):
    count = 0
    dummy = ListNode(-1)
    dummy.next = h
    n = dummy
    head = dummy

    while head:
        tail = head.next
        n = tail

        while n and count < k:
            n = n.next
            count += 1

        if count < k and not n:
            break

        count = 0
        stopN = n

        head.next = revK_r(tail, stopN)
        tail.next = stopN
        head = tail

    return dummy.next

 def oddEvenList(self, head):
     """
     :type head: ListNode
     :rtype: ListNode
     """
     if not head:
         return
     dummy1, dummy2 = ListNode(0), ListNode(0)
     dummy1.next = head
     dummy2.next = head.next
     dummy3 = head.next
     count = 3
     while head and dummy3 and dummy3.next and head.next:
         if head.next.next and not dummy3.next.next:
             head.next = head.next.next
             head = head.next
             break
         elif not head.next.next and dummy3.next.next:
             dummy3.next = dummy3.next.next
             dummy3 = dummy3.next
             break
         if count%2:
             head.next = head.next.next
             head = head.next
         else:
             dummy3.next = dummy3.next.next
             dummy3 = dummy3.next
     head.next = dummy2.next
     if dummy3:
         dummy3.next = None
     return dummy1.next

    def insertAtHead(self, item):
        
        '''
            pre:  an item to be inserted into list
            post: item is inserted into beginning of list
        '''

        node = ListNode(item)

        if not self.length:
            # set the cursor to the head because it's the
            # first item inserted into the list
            self.head = node 
        elif self.length == 1 and not self.tail:
            self.tail = self.head
            node.link = self.tail
            self.head = node
        else:
            node.link = self.head
            self.head = node

        # set the cursor to the head if it's not set yet
        if not self.cursor:
            self.cursor = self.head

        self.length += 1

def reverseLinkedListII(head, m, n):
    if head == None:
        return None
    dummy = ListNode(0)
    dummy.next = head
    head = dummy

    # find premmNode and mNode
    for i in range(1, m):
        head = head.next
    prevmNode = head
    mNode = head.next

    # reverse link from m to n
    nNode = mNode
    nextnNode = nNode.next
    for i in range(m, n):
        temp = nextnNode.next
        nextnNode.next = nNode
        nNode = nextnNode
        nextnNode = temp

    # combine
    prevmNode.next = nNode
    mNode.next = nextnNode

    return dummy.next

def generate_test_list3():
    n1 = ListNode(1)
    n2 = ListNode(2)
    n3 = ListNode(3)

    n1.next = n2
    n2.next = n3

    return n1

def addNumbers(h1, h2):
  l1, l2 = getLeng(h1), getLeng(h2)
  needToAdd1 = addNumRecur(h1, h2, l1 >= l2, abs(l1-l2))
  if needToAdd1:
    newN = ListNode(1)
    newN.next = (h1 if l1>=l2 else h2)
    return newN
  else:
    return (h1 if l1>=l2 else h2)

def test3():
    n1 = ListNode(1)
    n2 = ListNode(2)

    n2.next = n1

    h = n2
    rslt = mergeSort(h)
    ListNode.print_ll(rslt)

def test2():
    n1a = ListNode(1)
    n1b = ListNode(1)
    n1c = ListNode(1)

    n1a.next = n1b
    n1b.next = n1c
    rslt = removeElement(n1a, 1)
    print(ListNode.print_ll(rslt))

 def test_quicksort_list(self):
     A = ListNode.makeList([5, 4, 3, 2, 1, 6, 10, 7, 8, 9])
     quicksort_list(A, None)
     A.show()
     A = ListNode.makeList([2, 1, 2, 4, 5, 9, 8])
     quicksort_list(A, None)
     A.show()
     A = ListNode.makeList([10])
     quicksort_list(A, None)
     A.show()

def removeElement(n, val):
    dummyN = ListNode(-1)
    dummyN.next = n
    h = dummyN
    while h:
        if h.next and h.next.val == val:
            h.next = h.next.next
        else:
            h = h.next

    return dummyN.next

 def test004(self):
     
     print "test 004"
     
     n0 = ListNode(0)
     n0.next = n0
     
     hasCycle = Solution().hasCycle(n0)
     
     print "  expect:\t", True
     print "  output:\t", hasCycle
     print