剑指offerpython_剑指offer-Python版（上）

剑指offer上面的66道算法题是面试高频题，书中用C/C++写的答案，本篇笔记用python刷一遍所有的算法题，用于面试准备。题号顺序是牛客网上的顺序，答案都是牛客网编译通过的。由于内容过多，分了两节笔记。

另外，《剑指offer》这本书思路写的更详细，更清楚，可以参考。

1.二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

思路

类似于二分查找，根据题目，如果拿数组中任意一个元素与目标数值进行比较，如果该元素小于目标数值，那么目标数值一定是在该元素的下方或右方，如果大于目标数值，那么目标数值一定在该元素的上方或者左方。 对于二分查找来说，每次比较只能移动一个指针，在二维数组的查找中，两个指针是一个上下方向移动，一个是左右方向移动。两个指针可以从同一个角出发。 假设我们从左上角出发，也就是row=0 和 col=0，如果元素小于目标数值，我们会将row往下移或着col往右移，这样，被屏蔽的区域可能会是目标元素所在的区域。比如row+=1，那么第一行除左上角以外的元素就被忽略了，如果col+=1，那么第一列出左上角以外的元素就被忽略了。因此这样是不可行的。所以本题从右上角出发寻找解题思路。

代码

class Solution:

def Find(self, target, array):

rows = len(array)-1

cols = len(array[0]) - 1

i = rows

j = 0

while j<=cols and i>=0:

if target

i -= 1

elif target>array[i][j]:

j += 1

else:

return True

return False

2.替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

代码

class Solution:

# s 源字符串

def replaceSpace(self, s):

s_ = ''

for j in s:

if j == ' ':

s_ = s_ + '%20'

else:

s_ = s_ + j

return s_

3.从尾到头打印链表

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

思路：使用栈从头到尾push链表的元素，然后pop所有的元素到一个list中并返回。

代码

class Solution:

def printListFromTailToHead(self, listNode):

if not listNode:

return []

p = listNode

stack = []

res = []

while p:

stack.append(p.val)

p = p.next

for i in range(len(stack)-1,-1,-1):

res.append(stack[i])

return res

4.重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路：先序遍历和中序遍历的关系，先序遍历的第一个值是根节点的值。在中序遍历中，根节点左边的值是左子树，右边的值是右子树上的值。

代码

class Solution:

# 返回构造的TreeNode根节点

def reConstructBinaryTree(self, pre, tin):

if not pre:

return None

root = TreeNode(pre[0])

n = tin.index(root.val) #找到根节点在中序遍历中的下标

root.left = self.reConstructBinaryTree(pre[1:n+1],tin[:n])

root.right = self.reConstructBinaryTree(pre[n+1:],tin[n+1:])

return root

5.用两个栈实现一个队列

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

思路

定义两个stack，分别是stack1和stack2，队列的push和pop是在两侧的，push操作很简单，只需要在stack1上操作，而pop操作时，先将stack1的所有元素push到stack2中，然后stack2的pop返回的元素即为目标元素，然后把stack2中的所有元素再push到stack1中。

代码

class Solution:

def __init__(self):

self.stack1 = []

self.stack2 = []

def push(self, node):

self.stack1.append(node)

def pop(self):

if not self.stack1:

return None

while self.stack1:

self.stack2.append(self.stack1.pop())

res = self.stack2.pop()

while self.stack2:

self.stack1.append(self.stack2.pop())

return res

6.旋转数组中的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

思路：这个题很简单，题目说的不明白，意思是一个递增排序的数组做了一次旋转，给你旋转后的数组，找到最小元素。输入{3,4,5,1,2}输出1。

两个方法：1.遍历数组元素，如果前一个元素大于后一个元素，则找到了最小的元素。如果前一个一直小于后一个元素，说明没有旋转，返回第一个元素。

2.二分查找，如果中间元素位于递增元素，那么中间元素>最右边元素，最小元素在后半部分。否则，最小元素在前半部分。

代码

1.时间复杂度O(n)

class Solution:

def minNumberInRotateArray(self, rotateArray):

if not rotateArray:

return 0

for i in range(len(rotateArray)-1):

if rotateArray[i] > rotateArray[i+1]:

return rotateArray[i+1]

return rotateArray[0]

2.二分查找时间复杂度O(logn)

class Solution:

def minNumberInRotateArray(self, rotateArray):

if not rotateArray:

return 0

l = 0

r = len(rotateArray) - 1

while l < r:

mid = (l + r)/2

if rotateArray[mid] > rotateArray[r]:

l = mid+1

else:

r = mid

return rotateArray[l]

7.斐波那契数列

要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0），n<=39。

思路：菲波那切数列：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）

只需定义两个整型变量，b表示后面的一个数字，a表示前面的数字即可。每次进行的变换是： a,b = b,a+b

代码

class Solution:

def Fibonacci(self, n):

if n <= 0:

return 0

a = b = 1

for i in range(2,n):

a,b = b,a+b

return b

8.跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路：典型的动态规划问题，对于第n阶台阶来说，有两种办法，一种是爬一个台阶，到第n-1阶；第二种是爬两个台阶，到第n-2阶。

得出动态规划递推式：

代码

class Solution:

def jumpFloor(self, number):

if number < 0: return 0

if number == 1: return 1

if number == 2: return 2

result = [1, 2]

for i in range(2,number):

result.append(result[i-1] + result[i-2])

return result[-1]

9.变态跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路：n=0时,f(n)=0；n=1时,f(n)=1；n=2时,f(n)=2；假设到了n级台阶，我们可以n-1级一步跳上来，也可以不经过n-1级跳上来，所以f(n)=2*f(n-1)。

推公式也能得出：

n = n时：f(n) = f(n-1)+f(n-2)+...+f(n-(n-1)) + f(n-n) = f(0) + f(1) + f(2) + ... + f(n-1)

由于f(n-1) = f(0)+f(1)+f(2)+ ... + f((n-1)-1) = f(0) + f(1) + f(2) + f(3) + ... + f(n-2)

所以f(n) = f(n-1)+f(n-1)=2*f(n-1)

代码

class Solution:

def jumpFloorII(self, number):

if number <= 0: return 0

if number == 1: return 1

if number == 2: return 2

result = [1,2]

for i in range(2,number):

result.append(2*result[-1])

return result[-1]

10.矩阵覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

思路：n = 1: f(n) = 1; n=2 : f(n) = 2;

假设到了n，那么上一步就有两种情况，在n-1的时候，竖放一个矩形，或着是在n-2时，横放两个矩形（这里不能竖放两个矩形，因为放一个就变成了n-1，那样情况就重复了），所以总数是f(n)=f(n-1)+f(n-2)。时间复杂度O(n)。和跳台阶题一样。

代码

class Solution:

def rectCover(self, number):

if number <= 0: return 0

if number == 1: return 1

if number == 2: return 2

result = [1,2]

for i in range(2,number):

result.append(result[-1]+result[-2])

return result[-1]

11.二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。例如，9表示1001，因此输入9，输出2。

思路：如果整数不等于0，那么该整数的二进制表示中至少有1位是1。

先假设这个数的最右边一位是1，那么该数减去1后，最右边一位变成了0，其他位不变。

再假设最后一位不是1而是0，而最右边的1在第m位，那么该数减去1，第m位变成0，m右边的位变成1，m之前的位不变。

上面两种情况总结，一个整数减去1，都是把最右边的1变成0，如果它后面还有0，那么0变成1。那么我们把一个整数减去1,与该整数做位运算，相当于把最右边的1变成了0，比如1100与1011做位与运算，得到1000。那么一个整数中有多少个1就可以做多少次这样的运算。

代码

class Solution:

def NumberOf1(self, n):

count = 0

while n:

n = (n - 1) & n

count = count + 1

return count

12.数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

代码：考虑base=0/exponent=0/exponent<0的情况 。

class Solution:

def Power(self, base, exponent):

if exponent==0: return 1

if base==0: return 0

temp = 1

if exponent<0:

abs_exponent = -exponent

while abs_exponent>0:

temp = temp*base

abs_exponent = abs_exponent-1

return 1/temp

while exponent>0:

temp = temp*base

exponent = exponent-1

return temp

13.调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

代码：

#借助两个辅助的空间

class Solution:

def reOrderArray(self, array):

res1 = []

res2 = []

for i in array:

if i%2==1:

res1.append(i)

else:

res2.append(i)

array = res1 + res2

return array

不借助额外的空间，循环一次。p1和p2两个指针，p1指向第一个元素，p2指向第二个元素，p1找到第一个偶数，p2找到第一个奇数，[p1,p2-1]整体往后移一位，将奇数插到p1位置，然后p1+1。

class Solution:

def reOrderArray(self, array):

p1 = 0

while p1 < len(array):

while p1 < len(array) and array[p1]%2 == 1:

p1 += 1

p2 = p1+1

while p2 < len(array) and array[p2]%2 == 0:

p2 += 1

if p2 < len(array):

array.insert(p1,array.pop(p2))

p1 += 1

else:

break

return array

14.链表中的倒数第K个节点

输入一个链表，输出该链表中倒数第k个结点。

思路：假设链表中的节点数大于等于k个，那么一定会存在倒数第k个节点，首先使用一个快指针先往前走k步，然后两个指针每次走一步，两个指针之间始终有k的距离，当快指针走到末尾时，慢指针所在的位置就是倒数第k个节点。

代码

class Solution:

def FindKthToTail(self, head, k):

if not head or k <=0:

return None

p = q = head

t = 0

while p and t < k:

p = p.next

t = t+1

if t < k:

return None

while p != None:

p = p.next

q = q.next

return q

15.反转链表

class Solution(object):

def reverseList(self, head):

if not head:

return None

p = head

q = head.next

while q:

head.next = q.next

q.next = p

p = q

q = head.next

return p

16.合并两个排序的链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

class Solution(object):

def mergeTwoLists(self, l1, l2):

cur = head =ListNode(0)

while l1 and l2:

if l1.val <= l2.val:

cur.next = l1

l1 = l1.next

else:

cur.next = l2

l2 = l2.next

cur = cur.next

cur.next = l1 or l2

return head.next

17.树的子结构

输入两棵二叉树A，B，判断B是不是A的子结构。（空树不是任意一个树的子结构）

思路：采用递归的思路，单独定义一个函数判断B是不是从当前A的根节点开始的子树，这里判断是不是子树也需要一个递归的判断。如果是，则返回True，如果不是，再判断B是不是从当前A的根节点的左子节点或右子节点开始的子树。

class Solution:

def HasSubtree(self, pRoot1, pRoot2):

if not pRoot1 or not pRoot2:

return False

result = False

if pRoot1.val == pRoot2.val:

result = self.isSubTree(pRoot1,pRoot2)

if not result:

result = self.HasSubtree(pRoot1.left,pRoot2)

if not result:

result = self.HasSubtree(pRoot1.right,pRoot2)

return result

def isSubTree(self,pRoot1,pRoot2):

if not pRoot2:

return True

if not pRoot1:

return False

if pRoot1.val != pRoot2.val:

return False

return self.isSubTree(pRoot1.left,pRoot2.left) and self.isSubTree(pRoot1.right,pRoot2.right)

18.二叉树的镜像

操作给定的二叉树，将其变换为源二叉树的镜像。

二叉树的镜像定义：源二叉树

8

/ \

6 10

/ \ / \

5 7 9 11

镜像二叉树

8

/ \

10 6

/ \ / \

11 9 7 5

代码：交换左右结点

class Solution(object):

def invertTree(self, root):

if not root:

return None

root.left,root.right = self.invertTree(root.right),self.invertTree(root.left)

return root

19.顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路：输出第一行后逆时针翻转矩阵。

代码

class Solution:

# matrix类型为二维列表，需要返回列表

def printMatrix(self, matrix):

result = []

while(matrix):

result += matrix.pop(0)

if not matrix:

break

matrix = self.turn(matrix)

return result

def turn(self,matrix):

num_r = len(matrix)

num_c = len(matrix[0])

newmat = []

for i in range(num_c):

newmat2 = []

for j in range(num_r):

newmat2.append(matrix[j][i])

newmat.append(newmat2)

newmat.reverse()

return newmat

20.包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

class Solution:

def __init__(self):

self.stack = []

self.minStack = []

def push(self, node):

self.stack.append(node)

if not self.minStack or node < self.minStack[-1]:

self.minStack.append(node) #保存最小元素到栈顶

else:

self.minStack.append(self.minStack[-1])

def pop(self):

if self.stack:

self.stack.pop()

self.minStack.pop()

def top(self):

if self.stack:

return self.stack[-1]

else:

return None

def min(self):

if self.minStack:

return self.minStack[-1]

else:

return None

21.栈的压入、弹出

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

思路：栈的压入顺序是指1,2,3,4,5是依次push到栈的，但并不是说只有push的过程，也可能有pop的操作，比如push 1，2，3，4之后，把4pop出去，然后再push5，再pop5，然后依次pop3,2,1。弹出序列是指每次pop出去的元素都是当时栈顶的元素。

那么就可以构造一个辅助栈来判断弹出序列是不是和压栈序列对应。首先遍历压栈序列的元素push到辅助栈，判断是不是弹出序列的首元素，如果是，则弹出序列pop首元素（指针后移），如果不是，则继续push，再接着判断；直到遍历完了压栈序列，如果辅助栈或者弹出序列为空，则返回True，否则返回False

代码

class Solution:

def IsPopOrder(self, pushV, popV):

stack = []

for i in pushV:

stack.append(i)

while stack and stack[-1] == popV[0]:

stack.pop()

popV.pop(0)

if not stack:

return True

else:

return False

22.从上到下打印二叉树

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

#二叉树的层次遍历

class Solution:

def PrintFromTopToBottom(self, root):

if not root:

return []

stack = [root]

res = []

while stack:

temp = stack

stack = []

for node in temp:

res.append(node.val)

if node.left:

stack.append(node.left)

if node.right:

stack.append(node.right)

return res

23.二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

思路：递归判断。如果序列的长度小于2，那一定是后序遍历的结果。根据BST和后序遍历的性质，遍历结果的最后一个一定是根节点，那么序列中前面一部分小于根节点的数是左子树，后一部分是右子树，递归进行判断。

代码

class Solution:

def VerifySquenceOfBST(self, sequence):

if len(sequence) == 0:

return False

return self.subVerifySquenceOfBST(sequence)

def subVerifySquenceOfBST(self, sequence):

if len(sequence) <= 2:

return True

flag = sequence[-1]

index = 0

while sequence[index] < flag:

index += 1

j = index

while j < len(sequence)-1:

if sequence[j] > flag:

j += 1

else:

return False

return self.subVerifySquenceOfBST(sequence[:index]) and self.subVerifySquenceOfBST(sequence[index:-1])

24.二叉树中和为某一值的路径

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

思路：定义一个子函数，输入的是当前的根节点、当前的路径以及还需要满足的数值，同时在子函数中运用回溯的方法进行判断。

代码

class Solution:

# 返回二维列表，内部每个列表表示找到的路径

def FindPath(self, root, expectNumber):

self.res = []

if not root:

return []

self.subPath(root,[],expectNumber)

return self.res

def subPath(self, root, path,number):

if not root.left and not root.right:

if number == root.val:

self.res.append(path+[root.val])

if root.left:

self.subPath(root.left,path+[root.val],number-root.val)

if root.right:

self.subPath(root.right,path+[root.val],number-root.val)

25.复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

# def __init__(self, x):

# self.label = x

# self.next = None

# self.random = None

class Solution:

# 返回 RandomListNode

def Clone(self, pHead):

if pHead == None:

return None

# 新建一个链表的头结点

newhead = RandomListNode(pHead.label)

# 令头结点的random等于原来头节点的random

newhead.random = pHead.random

# 令头结点的next等于原来头结点的next (这一步可以省略，直接让newhead.next等于递归后的pHead.next)

newhead.next = pHead.next

# 递归处理newhead.next

newhead.next = self.Clone(pHead.next)

return newhead

26.二叉搜索树与双向链表

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路：题目很难理解，在网上找了个图。中序遍历，从中序遍历得到的第一个节点开始构造链表，定义两个辅助节点listHead(链表头节点)、listTail(链表尾节点)。listHead用于记录链表的头节点，用于最后算法的返回；listTail用于定位当前需要更改指向的节点。

class Solution:

def __init__(self):

self.listHead = None

self.listTail = None

def Convert(self, pRootOfTree):

if pRootOfTree == None:

return None

self.Convert(pRootOfTree.left)

if self.listHead == None:

self.listHead = pRootOfTree

self.listTail = pRootOfTree

else:

self.listTail.right = pRootOfTree

pRootOfTree.left = self.listTail

self.listTail = pRootOfTree

self.Convert(pRootOfTree.right)

return self.listHead

27.字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

思路：递归。把字符串分为两个部分： 字符串的第一个字符，第一个字符后面的所有字符。1.求所有可能出现在第一个位置的字符，用索引遍历。2.求第一个字符以后的所有字符的全排列。将后面的字符又分成第一个字符以及剩余字符。

class Solution:

def Permutation(self, ss):

if len(ss)==0 or len(ss)==1:

return ss

res = []

self.helper(ss, res, '')

return sorted(list(set(res)))

def helper(self, ss, res, path):

if not ss:

res.append(path)

else:

for i in range(len(ss)):

self.helper(ss[:i]+ss[i+1:],res,path+ss[i])

28.数组中出现次数超过一半的数字

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

解法1：对数组进行排序，如果该数存在，那么就是排序数组中间的数，判断这个数的个数是否大于一半，如果是，返回这个数，否则返回0。

class Solution:

def MoreThanHalfNum_Solution(self, numbers):

count = 0

numbers.sort()

res = numbers[len(numbers)/2]

for i in numbers:

if i == res:

count +=1

if count >len(numbers)/2:

return res

else:

return 0

解法2：假设第一个数字是众数，遍历数组，若元素 == 当前众数res则count += 1，否则count -= 1;

在下次count == 0时，意味着当前众数res的数量为已遍历元素一半；这种情况下，剩余数组众数仍等于原数组众数（因为最坏的情况是已遍历数组中一半是数组众数，一半是非众数）。

因此，在每次count == 0时，记录当前数字为当前众数，当遍历完整个数组时，留下的res一定为整个数组的众数（最坏情况是在最后一个元素才找到众数，前面的count全部抵消）。

最后验证这个数是否出现了一半以上。

class Solution:

def MoreThanHalfNum_Solution(self, numbers):

res=numbers[0]

count = 0

for i in numbers:

if res == i:

count +=1

else:

count -=1

if count < 0:

res = i

count = 1

count2 = 0

for i in numbers:

if res == i:

count += 1

if count > len(numbers)/2:

return res

else: return 0

29.最小的K个数

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

#堆排序

class Solution:

def GetLeastNumbers_Solution(self, tinput, k):

# write code here

if len(tinput) < k or k==0:

return []

self.buildHeap(tinput[:k],k)

for i in range(k,len(tinput)):

if tinput[i] > self.heap[0]:

continue

else:

self.heap[0] = tinput[i]

self.perceDown(0,k)

return sorted(self.heap)

def buildHeap(self,tinput,k):

self.heap = tinput

for i in range(k//2,-1,-1):

self.perceDown(i,k)

def perceDown(self,i,k):

temp = self.heap[i]

while (2 * i + 1) < k:

child = 2 * i + 1

if (child < k - 1) and self.heap[child] < self.heap[child+1]:

child = child + 1

if temp < self.heap[child]:

self.heap[i] = self.heap[child]

i = child

else:

break

self.heap[i] = temp

30.连续子数组的最大和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4],

输出: 6

解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

思路：如果数组里所有的整数都是负数，那么选择最大的数即可，因为越累加越小。

正负数都有的情况，需要两个变量，一个是global_max,从全局来看，每次最大的是什么组合，另一个是local_max，和global_max相比，更新global_max。

代码

class Solution(object):

def maxSubArray(self, nums):

if max(nums) < 0:

return max(nums)

local_max, global_max = 0, 0

for i in nums:

local_max = max(0, local_max + i)

global_max = max(global_max, local_max)

return global_max