58. 最后一个单词的长度
给定一个仅包含大小写字母和空格 ’ ’ 的字符串，返回其最后一个单词的长度。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指由字母组成，但不包含任何空格的字符串。
示例:
输入: “Hello World”
输出: 5
以下为上周最后提交的错误解法，郜学长指出，错误出在了line 11，j=s.index(i)，它永远都是第一个空格的索引，所以造成了无法识别连续空格的情况。
class Solution(object):
def lengthOfLastWord(self, s):
"""
:type s: str
:rtype: int
"""
a=[]
b=0
for i in s:
if i ==' ':
j=s.index(i)
a.append(j)
b+=1
if len(a)!=0:
return (len(s)-a[b-1]-1)
else:
return 0
随后，郜学长给出一种思路：使用split函数，以’ '为分隔符，把字符串分割为n个子字符串，计算最后一个字符串的长度。 但应该注意，当出现以空格结尾的情况时，系统不认为不存在最后一个单词（黑人问号脸.jpg），如“a ”，最后一个单词是“a”。所以应该在split之后，remove掉新列表中的空字符串，再输出最后一个字符串的长度。
class Solution(object):
def lengthOfLastWord(self, s):
"""
:type s: str
:rtype: int
"""
a=s.find(' ')
if a==-1:
return len(s)
else:
s1=s.split(' ')
while '' in s1:
s1.remove('')
if not s1:
return 0
else:
return(len(s1[-1]))
新知识积累：
- Python删除包含特定值的所有列表元素
while循环解决，while想删除内容存在时，list.remove()即可。直到全部remove完毕，退出循环。 - split（）函数
split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则从前往后仅分隔 num 个子字符串，返回分割后的字符串列表。
str.split(str="", num=string.count(str))
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。
70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
- 1 阶 + 1 阶
- 2 阶
示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
- 1 阶 + 1 阶 + 1 阶
- 1 阶 + 2 阶
- 2 阶 + 1 阶
class Solution(object):
def climbStairs(self, n):
"""
:type n: int
:rtype: int
"""
step=[1,2]
for i in range(2,n):
step.append(step[i-1]+step[i-2])
return step[n-1]
反着考虑比较好，欲达到第i阶，必先得达到第i-1阶或第i-2阶
设step[i]为达到第i+1阶的方法数，则step[i]=step[i-1]+step[i-2]
21. 合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
本题和下题都是有关于链表的题目，链表是新接触的知识。
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
head = ListNode(0)
first = head
while l1 != None and l2 != None:
if l1.val > l2.val:
head.next = l2
l2 = l2.next
else :
head.next = l1
l1 = l1.next
head = head.next
if l1 == None:
head.next = l2
elif l2 == None:
head.next = l1
return first.next
head= ListNode(0)这个意思是构造一个初始节点，也就是新链表的初始节点，其实可以把head理解为根节点；接着下一步是first = head，这一步很关键，因为如果不赋值的话，让head自身去不断next传递节点关系，那根节点就找不到了，所以需要先把head保存，接着进行一个while循环，条件是l1和l2这两个节点都不能为空，也就是说在两个链表长度范围之内遍历，当l1（初始是链表1的头节点）的值小于l2的值，那就把head的指向l1；最后循环结束了，肯定是其中有一个链表被遍历完了，也就是l1或者l2传递到了这两个链表的尾节点，没法再next下去了。跳出循环，此时来到了接下来的if l1 is None:这个判断条件，我们假设遍历完以后，l2所在的链表2还有剩余的几个节点，l1所在的链表1已经遍历完了，那么head.next = l2这个意思就是把head引向l2之后的那几个节点，也就是把新链表跟剩下的链表连接起来最后return的是first.next，因为first是根节点，first.next才是头节点.
第二种方法用到了递归，程序调用自身，极大缩短了篇幅，但是我并不能很好理解这种思想，求解答。
def mergeTwoLists(self, l1, l2):
if not l1:
return l2
elif not l2:
return l1
else:
if l1.val <= l2.val:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists(l1, l2.next)
return l2 `
83. 删除排序链表中的重复元素
给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
示例 1:
输入: 1->1->2
输出: 1->2
示例 2:
输入: 1->1->2->3->3
输出: 1->2->3
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if head is None:
return head
first=head
while head.next:
if head.val==head.next.val:
head.next=head.next.next
else:
head=head.next
return first
先判断链表是否为空，然后在while下一节点不为空时，判断头元素与头元素下一节点的值是否相等，相等则把下一节点值赋给当前节点，否则，进行下一节点的判断。返回，first。
88. 合并两个有序数组
给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:
初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
示例:
输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]
class Solution:
def merge(self, nums1, m, nums2, n):
"""
:type nums1: List[int]
:type m: int
:type nums2: List[int]
:type n: int
:rtype: void Do not return anything, modify nums1 in-place instead.
"""
nums1[m:m+n]=nums2[:n]
nums1.sort()
初始化 nums1 的元素数量分别为 m，这句话有些费解，通过看示例，大概就是取前m个元素，舍去其他的意思。
将nums1中第m+1到m+n个元素替换为nums2中前n个元素，再sort排序即可
注意题目要求
:rtype: void Do not return anything, modify nums1 in-place instead.
不返回，仅改变nums1即可。
100. 相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:
输入: 1 1
/ \ /
2 3 2 3
[1,2,3], [1,2,3]
输出: true
示例 2:
输入: 1 1
/
2 2
[1,2], [1,null,2]
输出: false
示例 3:
输入: 1 1
/ \ /
2 1 1 2
[1,2,1], [1,1,2]
输出: false
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution(object):
def isSameTree(self, p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
if not p and not q
return True
if p and q and p.val==q.val:
l=self.isSameTree(p.left,q.left)#递归，每次重新从函数入口处进行，每次进行递归边界判断
r=self.isSameTree(p.right,q.right)
return l and r#只用最后一次递归边界return值
else:
return False
先讨论两二叉树均为空的情况，返回true；从两棵树的同一位置的节点开始比较，若不同，则一定不同，返回false，若相同，以左右分支点作为新顶点采用递归，判断左右节点是否相同，仅都为true时才为true。本题的递归思想用的比较简单明了。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
