《剑指offer》python实现

最近需要抽时间帮老师完成一个项目，所以只能利用一些空闲时间来刷《剑指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)