乘积最大子序列
给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。
示例 1:
输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:
输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。
解法：
第一时间想到的是动态规划，想找当前位置上的乘积最大值，但是发现正负号的问题，即前一个位置上乘积最小值乘以当前位置上的数，可能会变成乘积最大值。
也就是两个dp数组，简化一下存储空间的话，就是两个值：前一个位置上的乘积最大值和乘积最小值。
每有一个新的数字加入，最大值要么是当前最大值*新数，要么是当前最小值（负数）*新数（负数），要么是新值。
class Solution(object):
def maxProduct(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
cur_min = cur_max = res = nums[0]
for i in range(1, len(nums)):
tmp_max = max(max(cur_min * nums[i], cur_max * nums[i]), nums[i])
tmp_min = min(min(cur_min * nums[i], cur_max * nums[i]), nums[i])
cur_min = tmp_min
cur_max = tmp_max
if cur_max > res:
res = cur_max
return res
旋转数组
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
示例 1:
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]
示例 2:
输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]
说明:
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
要求使用空间复杂度为 O(1) 的 原地 算法。
解法：
- 每次将整个数组向右移动一步，移动k次即可
- 运用python数组自带的切片方法，非常简单：nums[:]=nums[length-k:] + nums[:length-k]
- 经过3次子数组的 “对称翻折”：如 [1,2,3,4,5,6,7] 和 k = 3，第一步[1,2,3,4]->[4,3,2,1]，第二步[5,6,7]->[7,6,5]，最后[4,3,2,1,7,6,5]->[5,6,7,1,2,3,4]。
- 从第一个元素开始进行旋转，逐个将旋转位置上的元素移到下一个位置，直到旋转到该元素的初始位置。同时使用一个变量记录被旋转的元素数量，显然完成所有旋转后旋转元素数量应该是数组长度。（比较麻烦）
注意：
- k要对len求一下余
- 不知道为什么不能直接nums = list(reversed(nums))，可能是编辑器设置的问题，不过可以通过加上":"实现相同的功能
第三种解法：
class Solution(object):
def rotate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: None Do not return anything, modify nums in-place instead.
"""
k = k % len(nums)
pos = len(nums) - k
nums[:pos] = list(reversed(nums[:pos]))
nums[pos:] = list(reversed(nums[pos:]))
nums[:] = list(reversed(nums[:]))
第四种解法：
class Solution:
def rotate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: void Do not return anything, modify nums in-place instead.
"""
if len(nums)>1:
length = len(nums)
k = k%length
if k>0:
move_num = 0
move_pos = 0
move_value = nums[move_pos]
while move_num<length:
next_pos = (move_pos+k)%length
while next_pos!=move_pos:
save_value = nums[next_pos]
nums[next_pos] = move_value
move_value = save_value
next_pos=(next_pos+k)%length
move_num+=1
nums[move_pos]=move_value
move_num+=1
move_pos+=1
move_value = nums[move_pos]
移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。
解法：
- 自己想的一个，用index(0)判断最左边的0的位置是否已经是最后了，如果不是，就把0后面的所有内容往前移一个位置。总的看来，就是冒泡排序的加强版
- 其实可以不需要管中间移动的过程，只关注最终的结果即可。只要把数组中所有的非零元素，按顺序给数组的前段元素位赋值，剩下的全部直接赋值0就可以。
class Solution(object):
def moveZeroes(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
if 0 not in nums:
return nums
right = len(nums)
while nums.index(0) != right:
pos = nums.index(0)
nums[pos:right-1] = nums[pos+1:right]
nums[right-1] = 0
right -= 1
打乱数组
打乱一个没有重复元素的数组。
示例:
// 以数字集合 1, 2 和 3 初始化数组。
int[] nums = {1,2,3};
Solution solution = new Solution(nums);
// 打乱数组 [1,2,3] 并返回结果。任何 [1,2,3]的排列返回的概率应该相同。
solution.shuffle();
// 重设数组到它的初始状态[1,2,3]。
solution.reset();
// 随机返回数组[1,2,3]打乱后的结果。
solution.shuffle();
解法：
注意这里的随机要用洗牌方法：在每次迭代中，生成一个范围在当前下标到数组末尾元素下标之间的随机整数。接下来，将当前元素和随机选出的下标所指的元素互相交换。注意，当前元素是可以和它本身互相交换的 - 否则生成最后的排列组合的概率就不对了。
注意randint(min, max)的用法，min和max的值都可能被取到的。
init的时候保存两个，否则shuffle后就变化了原始数组
不明白： self.ori必须在self.arr前面定义，而且必须是nums[:]，是内部存储的一些问题么？如果定义的是self.ori = nums，修改arr的时候会把nums修改，进而把ori修改了。
import random
class Solution(object):
def __init__(self, nums):
"""
:type nums: List[int]
"""
self.ori = nums[:]
self.arr = nums
def reset(self):
"""
Resets the array to its original configuration and return it.
:rtype: List[int]
"""
return self.ori
def shuffle(self):
"""
Returns a random shuffling of the array.
:rtype: List[int]
"""
for i in range(len(self.arr)):
j = random.randint(i, len(self.arr)-1)
self.arr[i], self.arr[j] = self.arr[j], self.arr[i]
return self.arr
# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.reset()
# param_2 = obj.shuffle()
递增的三元子序列
给定一个未排序的数组，判断这个数组中是否存在长度为 3 的递增子序列。
数学表达式如下:
如果存在这样的 i, j, k, 且满足 0 ≤ i < j < k ≤ n-1，
使得 arr[i] < arr[j] < arr[k] ，返回 true ; 否则返回 false 。
说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1) 。
示例 1:
输入: [1,2,3,4,5]
输出: true
示例 2:
输入: [5,4,3,2,1]
输出: false
解法：
注意是递增的子序列，并没有说是“连续”子序列，但是还是走动态规划的思路，保存两个指针，一个min，一个medium；
一种方式是把min和medium初始化为最大值：float(“inf”)
另一种是设置一个flag标记下medium是否已经被初始化了。
因此遍历一遍数组，随时更新min和Medium的值，一旦遍历到比medium还大的数，直接返回ture
class Solution(object):
def increasingTriplet(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
if not nums:
return False
mi = nums[0]
flag = 0
for i in range(1, len(nums)):
tmp = nums[i]
if tmp < mi:
mi = tmp
elif tmp > mi and (flag == 0 or tmp < me):
me = tmp
flag = 1
elif flag == 1 and tmp > me:
return True
return False
两个数组的交集 II
给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
解法：
- 最简单的方法就是遍历两个数组，遇到相同的就记录下来，并删除掉该元素，避免重复。
- 先给两个数组排序，使用归并排序的思路。遇到两个数组的情况，如果要加速处理，就要想到可以设置两个指针。
解法1：
class Solution(object):
def intersect(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
res = []
for idx, x in enumerate(nums1):
if x in nums2:
res.append(x)
nums2.remove(x)
return res
解法2：
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
res = []
nums1 = sorted(nums1)
nums2 = sorted(nums2)
i = 0
j = 0
while i < len(nums1) and j < len(nums2):
if nums1[i] > nums2[j]:
j += 1
elif nums1[i] < nums2[j]:
i += 1
else:
res.append(nums1[i])
i += 1
j += 1
return res
除自身以外数组的乘积
给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
示例:
输入: [1,2,3,4]
输出: [24,12,8,6]
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。
进阶：
你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）
解法：
最简单的思路就是用除法或者O(n^2)的遍历，但是都被禁止了
其实想到用两个指针了，但是没想到用两个数组
因为是乘法，满足交换律，所以可以在第一遍遍历的时候把nums[i]左边部分的乘积存下来，第二遍的时候把右边的存下来，最后对应相乘就可以。（注意O(kn)=O(n)）
但是要在常熟空间复杂度的话，就只能保留一个数组，可以选择保留左边数组，右边的用一个数值代替就可以了，因为每次用完就不用了。
遍历nums，在遍历的过程中将对应元素累乘，例如
1 2 3 4
1 1 2 6
这样我们就得到了对应元素左边所有元素的乘积。然后我们反向遍历nums，做相同操作即可。
1 2 3 4
24 12 4 1
再将两个结果相乘即可。
1 2 3 4
24 12 8 6
Code
class Solution(object):
def productExceptSelf(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
left = [1] * len(nums)
right = 1
for i in range(1, len(nums)):
left[i] = left[i-1] * nums[i-1]
for i in range(len(nums)-1, -1, -1):
left[i] *= right
right *= nums[i]
return left
寻找数组的中心索引
给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。
我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。
示例 1:
输入:
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释:
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。
示例 2:
输入:
nums = [1, 2, 3]
输出: -1
解释:
数组中不存在满足此条件的中心索引。
说明:
nums 的长度范围为 [0, 10000]。
任何一个 nums[i] 将会是一个范围在 [-1000, 1000]的整数。
class Solution(object):
def pivotIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if not nums:
return -1
for i in range(len(nums)):
left = sum(nums[:i])
right = sum(nums[i+1:])
if left == right:
return i
return -1
至少是其他数字两倍的最大数
在一个给定的数组nums中，总是存在一个最大元素 。
查找数组中的最大元素是否至少是数组中每个其他数字的两倍。
如果是，则返回最大元素的索引，否则返回-1。
示例 1:
输入: nums = [3, 6, 1, 0]
输出: 1
解释: 6是最大的整数, 对于数组中的其他整数,
6大于数组中其他元素的两倍。6的索引是1, 所以我们返回1.
示例 2:
输入: nums = [1, 2, 3, 4]
输出: -1
解释: 4没有超过3的两倍大, 所以我们返回 -1.
提示:
nums 的长度范围在[1, 50].
每个 nums[i] 的整数范围在 [0, 100].
解法
就是求数组中的最大数和第二大数即可，注意第二大数的求法
class Solution(object):
def dominantIndex(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
m1, m2 = 0, 0
res = 0
for i, x in enumerate(nums):
if x > m1:
m2 = m1
m1 = x
res = i
elif x > m2:
m2 = x
if m1 >= m2 * 2:
return res
return -1
加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例 2:
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
解法
主要是对最后面是9的判断
class Solution(object):
def plusOne(self, digits):
"""
:type digits: List[int]
:rtype: List[int]
"""
if digits[-1] != 9:
digits[-1] += 1
return digits
idx = len(digits) - 1
while idx >= 0 and digits[idx] == 9:
digits[idx] = 0
idx -= 1
if idx == -1:
digits.insert(0, 1)
else:
digits[idx] += 1
return digits
对角线遍历
给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。
示例:
输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]
输出: [1,2,4,7,5,3,6,8,9]
解法
参考：https://leetcode-cn.com/problems/diagonal-traverse/solution/dui-jiao-xian-bian-li-by-leetcode/
初始化数组 result，用于存储最后结果。
使用一个外层循环遍历所有的对角线。第一行和最后一列的元素都是对角线的起点。
使用一个内层 while 循环遍历对角线上的所有元素。可以计算指定对角线上的元素数量，也可以简单迭代直到索引超出范围。
因为不知道每条对角线上的元素数量，需要为每条对角线分配一个列表或动态数组。但是同样也可以通过计算得到当前对角线上的元素数量。
对于奇数编号的对角线，只需要将迭代结果翻转再加入结果数组即可。
class Solution(object):
def findDiagonalOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
if not matrix or not matrix[0]:
return []
n, m = len(matrix), len(matrix[0])
res = []
for i in range(m + n + 1):
tmp = []
r, c = 0 if i < m else i - m + 1, i if i < m else m - 1
while r < n and c > -1:
tmp.append(matrix[r][c])
r += 1
c -= 1
if i % 2 == 0:
res.extend(tmp[::-1])
else:
res.extend(tmp)
return res
奇偶位排序
一个2*N长度数组，其中N个奇数，N个偶数，要求实现1个函数，把奇数放置到奇数下标，偶数放置到偶数下标
要求：1. 不能额外开辟一个内存/数组；2. 数组只能遍历1次
解法
就是可以看成是两个数组，一个奇数数组，一个偶数数组，所以也就是两个指针，都从左往右遍历，找到有问题的就交换。
def try(nums):
i, j = 0, 1
n = len(nums)
while i < n and j < n:
while nums[i] % 2 == 0 and i < n:
i += 2
while nums[j] % 2 == 1 and j < n:
j += 2
nums[i], nums[j] = nums[j], nums[i]
return nums