Leetcode学习笔记（6）
题目1 ID112
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树，以及目标和 sum = 22，
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
我的解答：
最开始的版本是这样的：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool hasPathSum(struct TreeNode* root, int sum){
if(root==NULL&&sum!=0){
return false;
}
if(root==NULL&&sum==0){
return true;
}
return hasPathSum(root->left,sum-root->val)||hasPathSum(root->right,sum-root->val);
}
使用递归和或运算，判断根节点到叶子结点中，是否有一条路径的和为sum对sum做减法，若某一个叶子结点处sum等于0，说明存在和为sum的路径，返回true。但是对于特殊输入值如:root为空树，sum=0的时候，本应该返回false，在上面的判断中却返回true，而这种情况又跟叶子结点判true是相同的，导致了错误。当输入案例为示例时，实际上代码是递归到2的左子树根节点时，才返回的true，因为2是叶子结点，所以其左子树根节点为NULL，从而导致跟特殊输入案例相同，将代码修改为在叶子结点时进行判断即可，修改后的代码如下：
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool hasPathSum(struct TreeNode* root, int sum){
if(root==NULL){
return false;
}
if(root->left==NULL&&root->right==NULL){
return sum-root->val==0;
}
return hasPathSum(root->left,sum-root->val)||hasPathSum(root->right,sum-root->val);
}
题目2 ID637
给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.
示例 1:
输入:
3
/ \
9 20
/ \
15 7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3, 第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].
注意：
节点值的范围在32位有符号整数范围内。
我的解答：
层序遍历，使用列表queue是否为空判断结束，每一层的非空节点值存在temp列表里面，当前层的值存在list1列表中，每往下一层，将temp赋给queue，当temp为空的时候，则证明没有新的为空的结点了，结束while循环。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def averageOfLevels(self, root: TreeNode) -> List[float]:
result=[]
if not root:
return result
queue=[root]
while len(queue)!=0:
list1=[]
temp=[]
for i in queue:
list1.append(i.val)
if i.left:
temp.append(i.left)
if i.right:
temp.append(i.right)
result.append(float(sum(list1))/len(list1))
queue=temp
return result
题目3 ID1305
给你 root1 和 root2 这两棵二叉搜索树。
请你返回一个列表，其中包含 两棵树 中的所有整数并按 升序 排序。.
示例 1：
输入：root1 = [2,1,4], root2 = [1,0,3]
输出：[0,1,1,2,3,4]
示例 2：
输入：root1 = [0,-10,10], root2 = [5,1,7,0,2]
输出：[-10,0,0,1,2,5,7,10]
示例 3：
输入：root1 = [], root2 = [5,1,7,0,2]
输出：[0,1,2,5,7]
示例 4：
输入：root1 = [0,-10,10], root2 = []
输出：[-10,0,10]
示例 5：
输入：root1 = [1,null,8], root2 = [8,1]
输出：[1,1,8,8]
提示：
每棵树最多有 5000 个节点。
每个节点的值在 [-10^5, 10^5] 之间。
我的解答：
我们已知二叉搜索树中序遍历之后的结果是一个升序序列，使用sortin函数对二叉树进行中序遍历，并将结果赋值给列表，两棵二叉树得到的列表都是升序序列，我们使用sort函数对其进行归并排序，返回最后的结果即两棵二叉树中所有整数的升序排列。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def sortin(self,root:TreeNode,sortlist:List):
if not root:
return None
self.sortin(root.left,sortlist)
sortlist.append(root.val)
self.sortin(root.right,sortlist)
def sort(self,sortlist1,sortlist2):
sortlist=[]
i,j=0,0
while True:
if i==len(sortlist1) or j==len(sortlist2):
break
if sortlist1[i]<sortlist2[j]:
sortlist.append(sortlist1[i])
i+=1
else:
sortlist.append(sortlist2[j])
j+=1
if i==len(sortlist1):
sortlist+=sortlist2[j:]
if j==len(sortlist2):
sortlist+=sortlist1[i:]
return sortlist
def getAllElements(self, root1: TreeNode, root2: TreeNode) -> List[int]:
if not root1 and not root2:
return []
sortlist1=[]
sortlist2=[]
self.sortin(root1,sortlist1)
self.sortin(root2,sortlist2)
return self.sort(sortlist1,sortlist2)
题目4 ID94
给定一个二叉树，返回它的中序 遍历。
示例:
输入: [1,null,2,3]
1
\
2
/
3
输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？
我的解答：
递归版本：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def __init__(self):
self.sortlist=[]
def inorderTraversal(self, root: TreeNode) -> List[int]:
if not root:
return []
self.inorderTraversal(root.left)
self.sortlist.append(root.val)
self.inorderTraversal(root.right)
return self.sortlist
非递归版本：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def inorderTraversal(self, root: TreeNode) -> List[int]:
stack,res=[],[]
temp=root
while stack or temp:
if temp:
stack.append(temp)
temp=temp.left
else:
temp=stack.pop()
res.append(temp.val)
temp=temp.right
return res
递归版本不再赘述，非递归版本：使用栈来辅助存储根节点，当左子树非空的时候，将左子树根节点入栈，并继续向下重复这一步骤，左子树为空的时候，按照中序遍历的顺序应该输出当前树根节点，此时的根节点在栈顶，弹出根节点并存储在res列表中，判断右子树是否为空，为空则继续弹出栈顶元素，非空则将右子树上的子树结点继续入栈。当栈为空同时结点也为空的时候，代表根节点们全部出栈完毕，同时没有结点入栈，则结束循环。
题目5 ID653
给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。
案例 1:
输入:
5
/ \
3 6
/ \ \
2 4 7
Target = 9
输出: True
案例 2:
输入:
5
/ \
3 6
/ \ \
2 4 7
Target = 28
输出: False
我的解答：
中序遍历二叉搜索树后，得到递增列表，使用双指针法判断是否存在两个元素的和等于给定目标值，left指向列表头，right指向列表尾，当left和right指向的值的和等于目标值时，找到这样的两个元素，返回true，当left和right指向的值的和大于目标值时，令right--，缩小两个元素的和，当left和right指向的值的和小于目标值时，令left++，扩大两个元素的和。若left>=right时，证明没有找到这样的两个元素，退出循环，返回false。
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def inorder(self,root:TreeNode):
if not root:
return []
self.inorder(root.left)
self.inlist.append(root.val)
self.inorder(root.right)
def findTarget(self, root: TreeNode, k: int) -> bool:
self.inlist=[]
self.inorder(root)
left,right=0,len(self.inlist)-1
while left<right:
if self.inlist[left]+self.inlist[right]==k:
return True
if self.inlist[left]+self.inlist[right]<k:
left+=1
if self.inlist[left]+self.inlist[right]>k:
right-=1
return False
题目6 ID69
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842...,
由于返回类型是整数，小数部分将被舍去。
我的解答：
最简单的方式，直接循环进行判断，时间复杂度为O(n)：
int mySqrt(int x){
long int i;
if(x==1){
return 1;
}
for(i=1;i<=x/2;i++){
if(i*i<=x&&(i+1)*(i+1)>x){
return i;
}
}
return 0;
}
使用二分查找法：
int mySqrt(int x){
long int i;
if(x==1){
return 1;
}
int low=1,high=x/2+1;
long int mid,val;
while(low<=high){
mid=(low+high)/2;
val=mid*mid;
if(val==x){
return mid;
}else if(val>x){
high=mid-1;
}else{
low=mid+1;
}
}
if(val>x){
return mid-1;
}
return mid;
}
题目7 ID559
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。
我的解答：
关键点在于临界条件的判断，多加练习
int search(int* nums, int numsSize, int target){
int low=0,high=numsSize-1;
while(low<=high){
int mid=(low+high)/2;
if(nums[mid]==target){
return mid;
}else if(nums[mid]>target){
high=mid-1;
}else{
low=mid+1;
}
}
return -1;
}
题目8 ID744
给你一个排序后的字符列表 letters ，列表中只包含小写英文字母。另给出一个目标字母 target，请你寻找在这一有序列表里比目标字母大的最小字母。
在比较时，字母是依序循环出现的。举个例子：
如果目标字母 target = 'z' 并且字符列表为 letters = ['a', 'b']，则答案返回 'a'
示例：
输入:
letters = ["c", "f", "j"]
target = "a"
输出: "c"
输入:
letters = ["c", "f", "j"]
target = "c"
输出: "f"
输入:
letters = ["c", "f", "j"]
target = "d"
输出: "f"
输入:
letters = ["c", "f", "j"]
target = "g"
输出: "j"
输入:
letters = ["c", "f", "j"]
target = "j"
输出: "c"
输入:
letters = ["c", "f", "j"]
target = "k"
输出: "c"
提示：
letters长度范围在[2, 10000]区间内。
letters 仅由小写字母组成，最少包含两个不同的字母。
目标字母target 是一个小写字母。
我的解答：
经过测试当数组中不不存在这样的字符时，返回数组的第一个字母，顺序遍历代码：
char nextGreatestLetter(char* letters, int lettersSize, char target){
int i;
for(i=0;i<lettersSize;i++){
if(letters[i]>target){
return letters[i];
}
}
return letters[0];
}
二分法查找代码，注意临界判断
char nextGreatestLetter(char* letters, int lettersSize, char target){
int low=0,high=lettersSize-1;
int mid;
while(low<high){
mid=(low+high)/2;
if(target>=letters[mid]){
low=mid+1;
}else{
high=mid;
}
}
if(letters[low]<=target){
return letters[0];
}else{
return letters[low];
}
}
题目9 ID35
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
示例 2:
输入: [1,3,5,6], 2
输出: 1
示例 3:
输入: [1,3,5,6], 7
输出: 4
示例 4:
输入: [1,3,5,6], 0
输出: 0
我的解答：
使用二分法，为了避免边界条件出错，可以用二分法的模板，特殊情况时再进行特殊考虑。
模板一：
int searchInsert(int* nums, int numsSize, int target){
int low=0,high=numsSize-1;
int mid;
while(low<=high){
mid=(low+high)/2;
if(nums[mid]==target){
return mid;
}else if(nums[mid]>target){
high=mid-1;
}else{
low=mid+1;
}
}
return low;
}
模板二：
int searchInsert(int* nums, int numsSize, int target){
int low=0,high=numsSize;
int mid;
while(low<high){
mid=(low+high)/2;
if(nums[mid]==target){
return mid;
}else if(nums[mid]>target){
high=mid;
}else{
low=mid+1;
}
}
return low;
}
题目10 ID136
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例 1:
输入: [2,2,1]
输出: 1
示例 2:
输入: [4,1,2,1,2]
输出: 4
我的解答：
这里用到了一个技巧：异或
异或具有以下几个性质：
1， 交换律 a^b^c等价于a^c^b
2， 任何数与0异或为原数 a^0=a
3， 相同的数异或等于0 a^a=0
所以我们只需要将数组中所有的数异或，就能够得到单独的那个数字
int singleNumber(int* nums, int numsSize){
int i;
int flag=0;
for(i=0;i<numsSize;i++){
flag=flag^nums[i];
}
return flag;
}
题目11 ID面试题53-II
一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。
示例 1:
输入: [0,1,3]
输出: 2
示例 2:
输入: [0,1,2,3,4,5,6,7,9]
输出: 8
限制：
1 <= 数组长度 <= 10000
我的解答：
方法一：
因为是递增排序数组数字是0到n-1，只需要将0到n-1的数字相加，再将数组中的数字求和，两者之差则为缺少的那个数字，如果差值为0.证明缺少的数字是n，如输入[0,1]，这样的案例，缺少的数字是2。
int missingNumber(int* nums, int numsSize){
int i;
if(nums[0]!=0){
return 0;
}
int sum1=0,sum2=0;
for(i=0;i<numsSize;i++){
sum1+=nums[i];
}
for(i=0;i<nums[numsSize-1]+1;i++){
sum2+=i;
}
if(sum2-sum1==0){
return numsSize;
}else{
return sum2-sum1;
}
}
方法二：
排序数组的搜索问题，应当第一时间想到二分法解决。经过观察可得，如果缺少的数字在数组中值的右边，则num[mid]==mid，令low=mid+1，若缺少的数字在数组中值的左边，则num[mid]!=mid，以此二分判断查找缺少数字的索引并返回。
int missingNumber(int* nums, int numsSize){
int low=0,high=numsSize-1;
while(low<=high){
int mid=(low+high)/2;
if(nums[mid]==mid){
low=mid+1;
}else{
high=mid-1;
}
}
return low;
}
浙公网安备 33010602011771号