第十周学习总结

Leecode的题目分析

参考了一些他人的思路

88 Merge Sorted Array

解题思路：设置遍历数组1和数组2的指针i=m-1，j=n-1，设置更新数组1的指针k=m+n-1。遍历数组，如果数组1中的值大于数组2，或者数组2遍历到头了，并且数组1没有到头，则更新数组1，nums1[k] = nums1[i–]，否则nums1[k] = nums2[j–]。当k小于0时遍历结束。

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        i=m-1
        j=n-1
        k=m+n-1
        while k>=0:
            if (j<0 or nums1[i]>nums2[j]) and i>=0:
                nums1[k]=nums1[i]
                i-=1
            else:
                nums1[k]=nums2[j]
                j-=1
            k-=1

912 Sort an Array
时间复杂度O（nlogn）空间复杂度O（nlogn）

class Solution(object):
    def sortArray(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        if len(nums) == 1:
            return nums

        mid = len(nums) / 2
        leftHalf = nums[:mid]
        rightHalf = nums[mid:]

        return self.mergeSort(self.sortArray(leftHalf), self.sortArray(rightHalf), nums)

    def mergeSort(self, leftHalf, rightHalf, nums):
        i, j, k = 0, 0, 0
        while i < len(leftHalf) and j < len(rightHalf):
            if leftHalf[i] < rightHalf[j]:
                nums[k] = leftHalf[i]
                i += 1
            else:
                nums[k] = rightHalf[j]
                j += 1
            k += 1

        while i < len(leftHalf):
            nums[k] = leftHalf[i]
            i += 1
            k += 1

        while j < len(rightHalf):
            nums[k] = rightHalf[j]
            j += 1
            k += 1
        return nums

147 Insertion Sort List
首先遍历原始链表，将其所有值append进一个list中接下来对list进行排序,最后一步将排序好的list中的值依次放入原始链表中。返回，结束。

class Solution(object):
    def insertionSortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next:
            return head
        temp = []
        node = head
        while node != None:
            temp.append(node.val)
            node = node.next
        temp.sort()
        node = head
        for n in temp:
            node.val = n
            node = node.next
        return head

148 Sort List
时间复杂度O（nlogn）空间复杂度O（n）
由于链表在归并操作时并不需要像数组的归并操作那样分配一个临时数组空间，所以这样就是常数空间复杂度了，当然这里不考虑递归所产生的。使用快慢指针，寻找中间值。

class Solution(object):
    def merge(self, h1, h2):
        dummy = tail = ListNode(None)
        while h1 and h2:
            if h1.val < h2.val:
                tail.next, tail, h1 = h1, h1, h1.next
            else:
                tail.next, tail, h2 = h2, h2, h2.next

        tail.next = h1 or h2
        return dummy.next

    def sortList(self, head):
        if not head or not head.next:
            return head

        pre, slow, fast = None, head, head
        while fast and fast.next:
            pre, slow, fast = slow, slow.next, fast.next.next
        pre.next = None

        return self.merge(*map(self.sortList, (head, slow)))