python刷题用leet乘风破万_LeetCode刷题临时记录-CSDN博客

113题没做出来

~~~

# Definition for a binary tree node.

# class TreeNode:

# def __init__(self, x):

# self.val = x

# self.left = None

# self.right = None

copyroot = root

rtype = [] #定义返回值

each_path_sum = [] #记录每一条路径的最后一个节点和这条路径的和，用一个tuple表示，list应该也可以，不能用dict

midTreeNode = root #定义一个用来循环的节点,保留root

while True:

path = [midTreeNode.val] #记录一条路径

path_sum = midTreeNode.val #记录与path相对应的和

if midTreeNode.left != None:

path.append(midTreeNode.val)

path_sum += midTreeNode.val

else:

each_path_sum.append((path,path_sum)) #当左叶为0，碰到了左叶子节点，先记录路径与和的元组

if mid

~~~

按顺序做

# 1

1.代码存在问题，循环得到结果后应当立即退出

2.如何跳出多层嵌套

3.两个相同的数怎么办

~~~

class Solution:

def twoSum(self, nums, target):

"""

:type nums: List[int]

:type target: int

:rtype: List[int]

"""

#重点是如何得到结果后跳出多层循环

#如何解决两个相同的数

n = len(nums)

for i in range(0,n):

for j in range(i+1,n):

if nums[i]+nums[j] == target:

rtype = [i,j]

return rtype

~~~

# 2

1. 注意事项太多啦做出来的第一道中等难度的题目，花了两天的时间这只是一个最初想到的方法绝对不是最简单的

2. 现在有一个思路，是在中间计算过程中，抛弃LIstNode这个类，直接转化为整数，那么应该可以简单很多

3. list中的类的初始化，不能用*，只能循环

4. 循环的跳出和进入

5. 循环的条件的设置

6. 判断的先后顺序

~~~

class Solution:

def addTwoNumbers(self, l1, l2):

"""

:type l1: ListNode

:type l2: ListNode

:rtype: ListNode

"""

# 得到链表的长度

ll1 = l1

ll2 = l2

i = 0

j = 0

while True:

while ll1.next != None:

i += 1

ll1 = ll1.next

else:

i += 1

while ll2.next != None:

j += 1

ll2 = ll2.next

else:

j += 1

if (ll1.next == None) and (ll2.next == None):

break

result = []

for index in range((max([i, j])+1)):

result.append(ListNode(0))

# 上面得到了存放结果的result列表，下面通过循环计算结果

temp = 0 #得到每一次计算的进位

i = 0 # 循环控制用

while ((l1.next != None) or (l2.next != None)) or (((l1.next == None) and (l2.next == None)) and ((l1.val !=0)or(l2.val != 0)or(temp>0))):

resu = l1.val + l2.val + temp

temp = 0

if resu >= 10:

temp = 1

resu = resu - 10

result[i].val = resu

else:

result[i].val = resu

if (l2.next == None) and (l1.next == None):

if temp > 0:

l1 = ListNode(0)

l2 = ListNode(0)

i += 1

else:

break

if (l1.next == None) and (l2.next != None):

l1 = ListNode(0)

l2 = l2.next

i += 1

if (l2.next == None) and (l1.next != None):

l2 = ListNode(0)

l1 = l1.next

i += 1

if (l1.next != None) and (l2.next !=None):

l1 = l1.next

l2 = l2.next

i += 1

for i in range(0,len(result)-1):

result[i].next = result[i+1]

if result[len(result)-1].val == 0:

result[len(result)-2].next = None

return result[0]

~~~

# 3

第三题自己的思路一开始就是错的，后来一时半会连正确的思路都想不到直接看答案了

为了看懂答案都想了两个多小时，确实很对的思路，仔细思考

这个代码哪一步都很巧很有可能是最佳算法

~~~

class Solution(object):

def lengthOfLongestSubstring(self, s):

"""

:type s: str

:rtype: int

"""

# 存储历史循环中最长的子串长度

max_len = 0

# 判断传入的字符串是否为空

if s is None or len(s) == 0:

return max_len

# 定义一个字典，存储不重复的字符和字符所在的下标

str_dict = {}

# 存储每次循环中最长的子串长度

one_max = 0

# 记录最近重复字符所在的位置+1

start = 0

for i in range(len(s)):

# 判断当前字符是否在字典中和当前字符的下标是否大于等于最近重复字符的所在位置

if s[i] in str_dict and str_dict[s[i]] >= start:

# 记录当前字符的值+1

start = str_dict[s[i]] + 1

# 在此次循环中，最大的不重复子串的长度

one_max = i - start + 1

# 把当前位置覆盖字典中的位置

str_dict[s[i]] = i

# 比较此次循环的最大不重复子串长度和历史循环最大不重复子串长度