第六章 LinkedList&Array

604—滑动窗口内数的和
描述

给你一个大小为n的整型数组和一个大小为k的滑动窗口，将滑动窗口从头移到尾，输出从开始到结束每一个时刻滑动窗口内的数的和。

样例

对于数组 [1,2,7,8,5] ，滑动窗口大小k= 3 。
1 + 2 + 7 = 10
2 + 7 + 8 = 17
7 + 8 + 5 = 20
返回 [10,17,20]

注意

异常情况要考虑周全

数组为空
数组元素个数不足k
数组不为空但k小于等于0

#2019/9/6

import sys

class Solution:
    def winSum(self,nums, k):
        if not nums or k <= 0:
            return []
        # print(nums[:k])
        wsum = sum(nums[:k])
        result = [wsum]
        for i in range(k, len(nums)):
            wsum = wsum+nums[i]-nums[i-k]
            result.append(wsum)
        return result


if __name__ == "__main__":
    a = Solution()
    arr = input()
    lines = [int(n) for n in arr.split(',')]
    # lines=sys.stdin.readline().strip()
    print("lines: ",lines)
    n = int(input())
    print(a.winSum(lines,n))

165. 合并两个排序链表
     中文English
     将两个排序链表合并为一个新的排序链表

Example
样例 1:
输入: list1 = null, list2 = 0->3->3->null
输出: 0->3->3->null

样例2:
输入: list1 = 1->3->8->11->15->null, list2 = 2->null
输出: 1->2->3->8->11->15->null

// An highlighted block
import sys
# Definition of ListNode
class ListNode(object):
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

class Solution:
    """
    @param l1: ListNode l1 is the head of the linked list
    @param l2: ListNode l2 is the head of the linked list
    @return: ListNode head of linked list
    """
    def getNewChart(self, list):
        if list:
            node = ListNode(list.pop(0))
            node.next = self.getNewChart(list)
            return node

    def mergeTwoLists(self, l1, l2):
        if not l1:
            return l2
        if not l2:
            return l1

        dummyHead = ListNode(0)
        # print("dumm: ",dummyHead.val)
        cur,p1,p2 = dummyHead,l1,l2
        # print("cur: ",cur.val)

        while p1 and p2:
            # print("p1: ",p1.val)
            if p1.val > p2.val:
                cur.next =p2
                p2 = p2.next
            else:
                cur.next = p1
                p1 = p1.next
            cur = cur.next

        if p1:
            cur.next =p1

        if p2:
            cur.next=p2

        print("cur---: ",cur.val)
        return dummyHead.next

if __name__ =="__main__":

    list1 = list(map(int,sys.stdin.readline().strip().split('->')))

    print('输入listO1:',list1)
    list2 = list(map(int,sys.stdin.readline().strip().split('->')))
    a = Solution()
    list1_1 = a.getNewChart(list1)
    list2_1 = a.getNewChart(list2)
    b = a.mergeTwoLists(list1_1,list2_1)


    while b != None:
        print(b.val, end=" ")
        b = b.next

138. 子数组之和
     中文English
     给定一个整数数组，找到和为零的子数组。你的代码应该返回满足要求的子数组的起始位置和结束位置

Example
样例 1:

输入: [-3, 1, 2, -3, 4]
输出: [0,2] 或 [1,3]
样例解释： 返回任意一段和为0的区间即可。
样例 2:

输入: [-3, 1, -4, 2, -3, 4]
输出: [1,5]
Notice
至少有一个子数组的和为 0

# class Solution:
#     def subarraySum(self,nums):
#         res = []
#         if nums is None or len(nums)<=0:
#             return res
#         d = {0:-1} #前缀和 ，下标
#         sum=0
#         for i in range(len(nums)):
#             sum+=nums[i]
#             if sum in d:
#                 res.append(i)
#                 res.append(d[sum]+1)
#                 return res
#             d[sum]=i
#         return res

if __name__ == '__main__':
    a = Solution()
    lin = list(map(int,sys.stdin.readline().strip().split(',')))
    print(a.subarraySum(lin))

#2019/9/6

98. 链表排序
    中文English
    在 O(n log n) 时间复杂度和常数级的空间复杂度下给链表排序。

Example
样例 1:
输入: 1->3->2->null
输出: 1->2->3->null

样例 2:
输入: 1->7->2->6->null
输出: 1->2->6->7->null

Challenge
分别用归并排序和快速排序做一遍。

// An highlighted block
import sys
class ListNode(object):
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

class Solution:

    def getNewChart(self, list):
        if list:
            node = ListNode(list.pop(0))
            node.next = self.getNewChart(list)
            return node

    def sortList(self,head):
        if not head:
            return None
        nums,cur = [],head
        while cur:
            nums.append(cur.val)
            cur = cur.next

        nums.sort()
        cur = head
        for num in nums:
            cur.val = num
            cur = cur.next

        return head

if __name__ == '__main__':
    a = Solution()

    list1 = list(map(int,sys.stdin.readline().strip().split('->')))
    list1_1 = a.getNewChart(list1)

    res = a.sortList(list1_1)


    while res != None:
        print(res.val, end="->")
        res = res.next

1->3->4->2
1->2->3->4->

105. 复制带随机指针的链表
     中文English
     给出一个链表，每个节点包含一个额外增加的随机指针可以指向链表中的任何节点或空的节点。

返回一个深拷贝的链表。

Challenge
可否使用O(1)的空间

// An highlighted block
var foo = 'bar';
2019/9/7

599. 向循环有序链表插入节点
     中文English
     给一个来自已经排过序的循环链表的节点，写一个函数来将一个值插入到循环链表中，并且保持还是有序循环链表。给出的节点可以是链表中的任意一个单节点。返回插入后的新链表。

Example
例1:

输入:
3->5->1
4
输出:
5->1->3->4
例2:

输入:
2->2->2
3
输出:
3->2->2->2
Notice
3->5->1 是一个循环链表，所以 3 是 1 的下一个节点。3->5->1 与 5->1->3 相同?

// An highlighted block
var foo = 'bar';
#2019/9/7

65. 两个排序数组的中位数
    中文English
    两个排序的数组A和B分别含有m和n个数，找到两个排序数组的中位数，要求时间复杂度应为O(log (m+n))。

Example
样例1

输入:
A = [1,2,3,4,5,6]
B = [2,3,4,5]
输出: 3.5
样例2

输入:
A = [1,2,3]
B = [4,5]
输出: 3
Challenge
时间复杂度为O(log n)

Clarification
中位数的定义：

这里的中位数等同于数学定义里的中位数。
中位数是排序后数组的中间值。
如果有数组中有n个数且n是奇数，则中位数为A[(n-1)/2]A[(n−1)/2]。
如果有数组中有n个数且n是偶数，则中位数为 (A[n / 2] + A[n / 2 + 1]) / 2(A[n/2]+A[n/2+1])/2.
比如：数组A=[1,2,3]的中位数是2，数组A=[1,19]的中位数是10。
https://blog.csdn.net/wenqiwenqi123/article/details/80668391

// An highlighted block
var foo = 'bar';

548. 两数组的交集 II
     中文English
     给定两个数组，计算两个数组的交集

Example
样例1

输入:
nums1 = [1, 2, 2, 1], nums2 = [2, 2]
输出:
[2, 2]
样例2

输入:
nums1 = [1, 1, 2], nums2 = [1]
输出:
[1]
Challenge
-如果给定的数组已经排序了怎么办?如何优化算法?
-如果nums1的大小比num2的小怎么办?哪种算法更好?
-如果nums2的元素存储在磁盘上，并且内存受到限制，以至于不能一次将所有元素加载到内存中，该怎么办?

Notice
每个元素出现次数得和在数组里一样
答案可以以任意顺序给出

// An highlighted block
var foo = 'bar';

96. 链表划分
    中文English
    给定一个单链表和数值x，划分链表使得所有小于x的节点排在大于等于x的节点之前。

你应该保留两部分内链表节点原有的相对顺序。

Example
样例 1:

输入: list = null, x = 0
输出: null
样例解释: 空链表本身满足要求
样例 2:

输入: list = 1->4->3->2->5->2->null, x = 3
输出: 1->2->2->4->3->5->null
样例解释: 要保持原有的相对顺序。

// An highlighted block
var foo = 'bar';

64. 合并排序数组
    中文English
    合并两个排序的整数数组A和B变成一个新的数组。

Example
样例 1:

输入：[1, 2, 3] 3 [4,5] 2
输出：[1,2,3,4,5]
解释:
经过合并新的数组为[1,2,3,4,5]
样例 2:

输入：[1,2,5] 3 [3,4] 2
输出：[1,2,3,4,5]
解释：
经过合并新的数组为[1,2,3,4,5]
Notice
你可以假设A具有足够的空间（A数组的大小大于或等于m+n）去添加B中的元素。

// An highlighted block
var foo = 'bar';

6. 合并排序数组 II
   中文English
   合并两个有序升序的整数数组A和B变成一个新的数组。新数组也要有序。

Example
样例 1:

输入: A=[1], B=[1]
输出:[1,1]
样例解释: 返回合并后的数组。
样例 2:

输入: A=[1,2,3,4], B=[2,4,5,6]
输出: [1,2,2,3,4,4,5,6]
样例解释: 返回合并后的数组。
Challenge
你能否优化你的算法，如果其中一个数组很大而另一个数组很小？

// An highlighted block
var foo = 'bar';

103. 带环链表 II
     中文English
     给定一个链表，如果链表中存在环，则返回到链表中环的起始节点，如果没有环，返回null。

Example
样例 1:

输入：null,no cycle
输出：no cycle
解释：
链表为空，所以没有环存在。
样例 2:

输入：-21->10->4->5，tail connects to node index 1
输出：10
解释：
最后一个节点5指向下标为1的节点，也就是10，所以环的入口为10。
Challenge
不使用额外的空间

// An highlighted block
var foo = 'bar';

41. 最大子数组
    中文English
    给定一个整数数组，找到一个具有最大和的子数组，返回其最大和。

Example
样例1:

输入：[−2,2,−3,4,−1,2,1,−5,3]
输出：6
解释：符合要求的子数组为[4,−1,2,1]，其最大和为 6。
样例2:

输入：[1,2,3,4]
输出：10
解释：符合要求的子数组为[1,2,3,4]，其最大和为 10。
Challenge
要求时间复杂度为O(n)

Notice
子数组最少包含一个数

// An highlighted block
var foo = 'bar';

42. 最大子数组 II
    中文English
    给定一个整数数组，找出两个 不重叠 子数组使得它们的和最大。
    每个子数组的数字在数组中的位置应该是连续的。
    返回最大的和。

Example
例1:

输入:
[1, 3, -1, 2, -1, 2]
输出:
7
解释:
最大的子数组为 [1, 3] 和 [2, -1, 2] 或者 [1, 3, -1, 2] 和 [2].
例2:

输入:
[5,4]
输出:
9
解释:
最大的子数组为 [5] 和 [4].
Challenge
要求时间复杂度为 O(n)

Notice
子数组最少包含一个数

// An highlighted block
var foo = 'bar';

43. 最大子数组 III
    中文English
    给定一个整数数组和一个整数 k，找出 k 个不重叠子数组使得它们的和最大。每个子数组的数字在数组中的位置应该是连续的。

返回最大的和。

Example
样例1

输入:
List = [1,2,3]
k = 1
输出: 6
说明: 1 + 2 + 3 = 6
样例2

输入:
List = [-1,4,-2,3,-2,3]
k = 2
输出: 8
说明: 4 + (3 + -2 + 3) = 8
Notice
子数组最少包含一个数

// An highlighted block
var foo = 'bar';