最近需要抽时间帮老师完成一个项目,所以只能利用一些空闲时间来刷《剑指offer》,速度很慢
两个链表的第一个公共结点
题目描述:
输入两个链表,找出它们的第一个公共结点。
思路:
由于链表一旦产生公共节点,那公共节点之后的两个链表的节点都是相同的(一个节点只能指向一个物理位置),因此将两个链表的所有节点放在两个栈里,从栈的尾部开始寻找,找到最后一个不相同的节点就是第一个公共节点
class Solution:
def FindFirstCommonNode(self, pHead1, pHead2):
#将两个链表的所有节点放在两个栈里
l1=0
s1=[]
while pHead1:
l1+=1
s1.append(pHead1)
pHead1=pHead1.next
l2=0
s2=[]
while pHead2:
l2+=1
s2.append(pHead2)
pHead2=pHead2.next
#从尾部开始找,因为一旦产生公共节点,后面的所有元素都相同,找到最后一个相同的节点即可。
res=None
while len(s1)!=0 and len(s2)!=0:
v1=s1.pop()
v2=s2.pop()
if v1==v2:
res=v1
continue
else:
break
return res
数字在排序数组中出现的次数
题目描述:
统计一个数字在排序数组中出现的次数。
思路:
由于数组是排好序的数组,有两个方法统计一个数出现的次数,一是遍历循环,二是二分查找
- 遍历循环的方法
class Solution:
def GetNumberOfK(self, data, k):
count=0
falg=False
for i in range(len(data)):
if data[i]==k:
count+=1
falg=True
continue
elif not falg:
continue
break
return count
#最普通的遍历方法
- 二分查找的方法,首先使用二分法找到这个数出现的位置,然后分别向左向右搜索这个数出现的次数即可【虽然使用二分查找将时间复杂度从O(N)变为了O(logN),但是在牛客网上的运行时间并没有快很多,估计是算例个数太少】
class Solution:
def GetNumberOfK(self, data, k):
left=0
right=len(data)-1
if not data:
return 0
#使用二分查找,找到出现这个数字的位置,下面是标准的二分查找的写法
while(left<=right):
mid=(left+right)/2
if data[mid]==k:
break
if data[mid]>k:
right=mid-1
elif data[mid]<k:
left=mid+1
#如果找到了mid,count先增加1
if data[mid]==k:
count=1
else:
return 0
#分别向左向右找到其余的数字
posl,posr=mid-1,mid+1#找到k的左右位置
#注意不要超出边界
while(posl!=-1):
if data[posl]==k:
posl-=1
count+=1
else:
break
while(posr!=len(data)):
if data[posr]==k:
posr+=1
count+=1
else:
break
return count
二叉树的深度
题目描述:
输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。
思路:
本题两个思路,一个是使用递归的方法,一个是使用队列的方法:
- 递归
递归的方法返回左右子树的大的深度+1
#使用递归的方法写的,左右分别递归调用
class Solution:
def TreeDepth(self, pRoot):
# write code here
if not pRoot:
return 0
else:
return max(1+self.TreeDepth(pRoot.left),1+self.TreeDepth(pRoot.right))
- 层次遍历方法
使用层次遍历方法,每次将一层的的节点放在队列中,记录本层节点个数,然后对将每一个节点的左右节点放在队列中,之后将该层的节点移除,二叉树的深度加1,循环至队列中没有节点为止
#使用层次遍历的方法,用队列储存每一层的内容
class Solution:
def TreeDepth(self, pRoot):
if not pRoot:
return 0
depth=0
store=[]
#将根节点放在队列中
store.append(pRoot)
while(len(store)!=0):
#首先记录本层的节点个数
thislevel=len(store)
#依次将本次每个节点的左右节点放在队列中
for i in range(thislevel):
if store[i].left:
store.append(store[i].left)
if store[i].right:
store.append(store[i].right)
#将本层的每个节点移除
for i in range(thislevel):
store.pop(0)
#遍历一遍层数加1
depth+=1
return depth
平衡二叉树
题目描述:
输入一棵二叉树,判断该二叉树是否是平衡二叉树。
思路:
本题依旧是两个思路,一个是计算每一个节点的左右子树的高度,判断高度差是否小于1,二是对于每一个节点,如果其中左或右树不为二叉平衡树,则将其高度设为-1,一旦判断到那个树的高度为-1,上一层也返回-1,否则返回该树的高度。
- 方法1,递归的时候还需要调用上一题的计算二叉树深度的函数,因此时间复杂度为O(N)
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#使用计算左右子树的方法,来判断是否是一个平衡二叉树,时间复杂度是n^2的
class Solution:
def IsBalanced_Solution(self, pRoot):
# write code here
if not pRoot:
return False
#计算左右树的高度需要进行一次递归,时间复杂度为n
leftdepth=self.TreeDepth(pRoot.left)
rightdepth=self.TreeDepth(pRoot.right)
if abs(leftdepth-rightdepth)<=1:
flag=True
else:
flag=False
#每个节点要重复调用自己的判断函数,时间复杂度为n,因此总的时间复杂度为n^2
return flag and self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
def TreeDepth(self, pRoot):
#调用上一题写的计算一个二叉树深度的函数
if not pRoot:
return 0
else:
return max(1+self.TreeDepth(pRoot.left),1+self.TreeDepth(pRoot.right))
- 方法二,使用一个helper函数,计算二叉树的深度,但是如果一个节点的左右子树高度差大于1,则将该节点的深度设为-1,之后判断时,如果遇到-1的节点,则证明其中包含一个不平衡的二叉树,也返回-1
#这种解法的时间复杂度降到n,原因是每次遍历,如果不符合高度要求,直接返回-1
class Solution:
def IsBalanced_Solution(self, pRoot):
return self.helper(pRoot)!=-1
#定义辅助函数,只要某一个树的值设为-1,证明该树中有不平衡二叉树,这个树以上的所有树都为不平衡二叉树
def helper(self,pRoot):
if not pRoot:
return 0
left=self.helper(pRoot.left)
if left==-1:
return -1
right=self.helper(pRoot.right)
if right==-1:
return -1
#如果两个树都没有不平衡二叉树,需要判断左右树的高度差是否<1,如果不小于1,需要返回该树的高度
if abs(left-right)>1:
return -1
return 1+max(left,right)