剑指offer刷题0403

参考和感谢：https://codingcat.cn/article/30#

 

平衡二叉树

数组只出现一次

    enumerate的用法与词典遍历时曾经没有明确的python语法点

和为s的连续正数序列 

和为s的两个数字

 

 

 

平衡二叉树

题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

思路： 首先平衡二叉树的定义与性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

###看似简单，但是在写递归的时候，要注意是对左右子树是否为平衡二叉树来判断。另外对于递归里面树的高度要注意写法，借助类似后序遍历的思想和具体的赋值细节。“左右子树的高度”其实质左右子树仍是个根节点，利用此来求节点高度。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code here
        ###看似简单，但是在写递归的时候，要注意。另外对于递归里面树的高度要注意写法
        if not pRoot:
            return True  #注意空树也是二叉平衡树
        is_left=self.IsBalanced_Solution(pRoot.left)
        if not is_left:
            return False
        is_right=self.IsBalanced_Solution(pRoot.right)
        if not is_right:
            return False
        #左右均平衡，则计算左右子树的深度，判断当前为根的树是否平衡
        #此要注意计算子树深度在此递归中的写法
        left_depth=pRoot.left.depth if pRoot.left else 0 #注意给pRoot.left.path赋值的操作
        #注意 d=c if a else b 表示的是如果a非None 则将c 赋值给d,否则将b 赋值给d
        #而pRoot.left.depth具体的求的是通过后面的pRoot.depth 上一轮的递归中求的,此自己写要注意细节
        #类似后序遍历,左，右，根
        right_depth=pRoot.right.depth if pRoot.right else 0
        #树的高度求法，根的高度为左右子树高度中大值+1，另一方面，左右子树又可看成是各有根节点的树
        pRoot.depth=max(left_depth,right_depth)+1
        return abs(left_depth-right_depth)<=1

数组只出现一次

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

思路分析： 方法1：用dict记录每个数字出现的次数，然后在找字典dict中值为1的即可，时间复杂度O（n）,空间O（n）。此方法注意自己暴露出的对dict遍历与enumerate知识点相关的问题。

** 方法2 ，利用set，如果第一次出现加入，如果出现了两次，则将原来的那个也删掉，留下的就是只有一次的了。

 

# -*- coding:utf-8 -*-
#方法1
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
                # write code here
        #遍历数组，用dict记录它出现的次数
        if not array:
            return -1
        count_array={}
        for i in array:
            if i  in count_array:
                count_array[i]+=1
            else:
                count_array[i]=1
        result_list=[]
        print(count_array)
        for key in count_array:
            if count_array[key]==1:
                result_list.append(key)
                print(key)
        return result_list
 
# ss=[11,2,3,1,3]
# aca=FindNumsAppearOnce(ss)
# print(aca)

#方法2：，利用set
# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        data=set()
        for d in array:
            if d in data:
                data.remove(d)
            else:
                data.add(d)
        return list(data)
        

#字典的遍历与enumerate注意
count_dict={'aa':2,'bb':3,'cc':22}
aam=enumerate(count_dict)  #一个迭代对象
print(aam)
for i in aam: #表名字典经过enumerate后生成的迭代对象只保留了key的值，新给的索引从0开始.1,..n，索引对应的值为原dict中的key的值
    print(i)
for key in count_dict:
    #对字典进行for遍历，for i in dict中，i只会是key,要想得到value,则在后面的语句中用dict[key]取得
    print(key)
    print(count_dict[key])

和为s的连续正数序列 

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述： 输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

思路：

用两个指针，一个small，一个big。开始时，small指向1，big指向2。我们以s=9为例，一开始{1，2}，和为3，小于s，则让big往后移动，{1，2，3}，再继续{1，2，3，4}，此时和为10，大于s，则让small往后移动，{2，3，4}，等于9，找到一个，然后继续增加big， ，{2，3，4，5}大于s，让small往后，{3，4，5}大于s，让small往后，{4，5}等于9，找到一个，再让big往后，{4，5，6}大于s，让small往后，{5，6}，此时small已经大于9的一半了，不再继续寻找。

这样不会遗漏吗？比如，当和大于s时，为什么不让big往前走？是因为big之所以到这里，是由于它之前的和大于s了，再让big往前，和会更大于s（因为个数都多了）；当小于s时为什么不让small往前走？是因为small之所以到这里，是由于它之前的和会更大于s了（因为个数少了），再让small往前，和会更小于s。（此处参考的同学这写的有点问题）

 

# -*- coding:utf-8 -*-
class Solution:
    def FindContinuousSequence(self, tsum):
        if not tsum:
            return []
        result = []
        small = 1
        big = 2
        current_sum = small + big
        while small < (tsum + 1) / 2:
            while current_sum < tsum:
                big += 1
                current_sum += big
            while sum(range(small, big + 1)) > tsum:
                current_sum -= small
                small += 1
            if current_sum == tsum and small != big:
                result.append(list(range(small, big + 1)))
                big += 1
                current_sum += big
        return result

 

和为s的两个数字

问题 输入一个递增排序的数组，和一个数字s，在数组中查找两个数，使它们的和正好是s。如果有多对和为s，输出两个数的乘积最小的。 输出描述: 对应每个测试案例，输出两个数，小的先输出。
思路 两个指针分别指向首尾，两个值相加如果大于s，则让后面的指针往前走一走，如果小于s则让前面的指针往后走一走，直到找到和为s，或者指针重合也没找到。 注意和上一题的思路分析有差异，上一题个数未确定，此个数确定了，如果大于，则大的向左走（向前）。

为什么这样可行呢？如果值小于s，为什么不让后面的指针往后走，和也能变大呢？这是因为，后面的指针如果能够往后走（说明它曾经往前走过），是因为它加上数组最小的值之后还是大于s了，所以这时如果让后面指针往后走，结果必定大于s。如果值大于s，为什么不让前面的指针往前走呢？这是因为，如果前面的指针能往前走（说明它曾经往后走过），是因为它加上数组最大的值之后还是小于s了，这时往前走了，结果也必定小于s，没有必要。

 

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        if not array or not tsum:
            return []
        front = 0
        rear = len(array) - 1
        while front < rear:
            added = array[front] + array[rear]
            if added == tsum:
                return [array[front], array[rear]]
            elif added < tsum:
                front += 1
            else:
                rear -= 1
        return []