1、（41） 最大子数组
描述：给定一个整数数组，找到一个具有最大和的子数组，返回其最大和。
注意事项：子数组最少包含一个数
样例：给出数组[−2,2,−3,4,−1,2,1,−5,3]，符合要求的子数组为[4,−1,2,1]，其最大和为6
挑战 ：要求时间复杂度为O(n)
标签 ：贪心 领英 子数组 数组 LintCode 版权所有 枚举法
def maxSubArray(self, nums):
max_number = nums[0]
sum = 0
for i in nums:
sum += i
max_number = max(max_number, sum)
sum = max(sum, 0)
return max_number2、（167）链表求和
描述：你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。
样例：给出两个链表 3->1->5->null 和 5->9->2->null，返回 8->0->8->null
标签：链表 Cracking The Coding Interview 高精度
def addLists(self, l1, l2):
add=0
cur1,cur2=l1,l2
l3 = ListNode(-1)
pre = l3
while cur1 or cur2:
if cur1 and cur2:
temp = (cur1.val + cur2.val +add)
cur1=cur1.next
cur2 =cur2.next
elif cur1:
temp = (cur1.val+add)
cur1 = cur1.next
else:
temp = (cur2.val+add)
cur2 = cur2.next
add = temp//10
pre.next = ListNode(temp%10)
pre = pre.next
if add==1:
pre.next = ListNode(1)
return l3.next3、（413）反转整数
(http://blog.csdn.net/guoziqing506/article/details/51563779)
描述：将一个整数中的数字进行颠倒，当颠倒后的整数溢出时，返回 0 (标记为 32 位整数)。
样例：
给定 x = 123，返回 321
给定 x = -123，返回 -321
def reverseInteger(self, n):
max_int = 2147483647
temp = abs(n)
result = 0
while temp > 0:
result *= 10
result += temp % 10
if result > max_int:
return 0
temp = temp // 10 #整数除法，‘/’浮点型
return result if n >= 0 else -result 4、（46）主元素
描述：给定一个整型数组，找出主元素，它在数组中的出现次数严格大于数组元素个数的二分之一。
样例：给出数组[1,1,1,1,2,2,2]，返回 1
def majorityNumber(self, nums):
nums.sort()
index = 0
value = nums[0]
count = 0
while index<len(nums):
if nums[index]==value:
count+=1
index+=1
if count > len(nums)/2:return value
else:
value=nums[index]
index+=1
count= 1#判断出不相等，已经有一个计数了别人的，果然不是我这种菜鸟能比的呀。但是我觉得我的简洁明了，哈哈哈
http://blog.csdn.net/guoziqing506/article/details/51434299
def majorityNumber(self, nums):
ele = nums[0]
count = 0
for i in nums:
if ele == i:
count += 1
else:
count -= 1
if count <= 0:
ele = i
return ele 5、407. 加一
描述:给定一个非负数，表示一个数字数组，在该数的基础上+1，返回一个新的数组。
该数字按照大小进行排列，最大的数在列表的最前面。
样例: 给定 [1,2,3] 表示 123, 返回 [1,2,4].
给定 [9,9,9] 表示 999, 返回 [1,0,0,0].
index = -1
count =0
if digits[-1]!=9:
digits[-1]+=1
return digits
else:
while digits[index]==9 and abs(index)<=len(digits)+1:
count += 1
index-=1
if count==len(digits):
digits.append(0)
digits[0]=1
for i in range(1,len(digits)-1):
digits[i]=0
else:
digits[index] += 1
for j in range(index+1,0,1):
digits[j]=0
return digits感觉特别的繁琐
result = []
n = len(digits) - 1
add1 = 1
while n >= 0:
temp = digits[n] + add1
result.insert(0, temp % 10)
add1 = temp // 10
n -= 1
if add1 == 1:
result.insert(0, 1)
return result这是别人的，不看不知道，一秒成渣啊
6、35. 翻转链表
描述：翻转一个链表
样例：给出一个链表1->2->3->null，这个翻转后的链表为3->2->1->null
挑战 ：在原地一次翻转完成
标签 ：链表 优步 脸书
分析：题目要求原地翻转，如果不做要求，我们可以建一个空链，依次摘链，添加
原地翻转，依次摘链，链接
"""
Definition of ListNode
class ListNode(object):
def __init__(self, val, next=None):
self.val = val
self.next = next
"""
class Solution:
"""
@param: head: n
@return: The new head of reversed linked list.
"""
def reverse(self, head):
if head == None:return head
dummy=ListNode(0)
dummy.next = head
pre =head
cur =head.next
while cur:
temp = cur
pre.next=cur.next
cur = cur.next
temp.next = dummy.next
dummy.next = temp
return dummy.next
123，从2开始摘链，依次向前添加
7、165. 合并两个排序链表
描述：将两个排序链表合并为一个新的排序链表
样例：给出 1->3->8->11->15->null，2->null， 返回 1->2->3->8->11->15->null。
标签 : 领英 链表
分析：两个指针遍历，（1）如果l1>l2，添加，改变pre，next节点，两个指针都要移动。（2）else，移动l2的指针，接着比较。如果l1遍历完了,l2还有数据，直接接上就行
def mergeTwoLists(self, l1, l2):
dummy=ListNode(0)
cur1,cur2=l1,l2
pre = dummy
dummy.next=l1
while cur1 and cur2:
if cur1.val>=cur2.val:
temp = cur2
cur2=cur2.next
pre.next = temp
pre = temp
temp.next = cur1
else:
pre = pre.next
cur1 = cur1.next
if cur2:#如果l2还有数据，直接链表连接
pre.next = cur2
return dummy.next8、（491） 回文数
描述：判断一个正整数是不是回文数。
回文数的定义是，将这个数反转之后，得到的数仍然是同一个数。
注意事项：给的数一定保证是32位正整数，但是反转之后的数就未必了。
样例：
11, 121, 1, 12321 这些是回文数。
23, 32, 1232 这些不是回文数。
标签 ：字符串处理 整数
分析：现将数字按列表存放
判断中位之前和之后的数字是否对应相等
def isPalindrome(self, num):
a = []
while num>0:
temp = num%10
a.insert(0,temp)
num = num//10
n = len(a)-1
index = 0
while index<=n//2:
if a[index]==a[n-index]:
index+=1
else:
break
if index-1==n//2:return True#注意注意 不知道怎么改简洁
else:return False