剑指offer系列之知识迁移能力(p36-43)

36. 数字在有序数组中出现的次数

题目描述

本题知识点： 数组
统计一个数字在排序数组（默认为升序）中出现的次数。

思路

看到有序数组直接联想到二分查找。

思路一

查找比指定值大一点和小一点的数（均不在数组中）的起始位置，直接相减得到指定值出现的次数。时间复杂度为$O(logn)$.

# -*- coding:utf-8 -*-
class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        return self.BiSearch(data, k+0.5) - self.BiSearch(data, k-0.5)
    
    def BiSearch(self, data, num):
        s, e = 0, len(data) - 1
        while s <= e:
            mid = (e - s) // 2 + s
            if data[mid] < num:
                s = mid + 1
            elif data[mid] > num:
                e = mid - 1
        return s

思路二

查找指定值的第一次出现的位置和最后一次出现的位置，直接相减即可。时间复杂度为$O(logn)$.

# -*- coding:utf-8 -*-
class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        l = len(data)
        if l == 0:
            return 0
        firstPos = self.getFirstPos(data, 0, l-1, k)
        lastPos = self.getLastPos(data, 0, l-1, k)
        if firstPos!=-1 and lastPos!=-1:
            return lastPos - firstPos + 1
        return 0
    
    # 递归实现二分查找法
    def getFirstPos(self, data, start, end, k):
        if start > end:
            return -1
        mid = (end - start) // 2 + start
        if data[mid] < k:
            return self.getFirstPos(data, mid+1, end, k)
        elif data[mid] > k:
            return self.getFirstPos(data, start, mid-1, k)
        elif mid-1 >= 0 and data[mid-1] == k:
            return self.getFirstPos(data, start, mid-1, k)
        else:
            return mid
    
    # 循环实现热分查找法
    def getLastPos(self, data, start, end, k):
        while start <= end:
            mid = (end - start) // 2 + start
            if data[mid] > k:
                end = mid -1
            elif data[mid] < k:
                start = mid + 1
            elif mid+1 < len(data) and data[mid+1]==k:
                start = mid + 1
            else:
                return mid
        return -1

37. 二叉树的深度

题目描述

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

思路

思路一：递归算法

左右子树中深度较大的那个加上高度为1的跟结点即得到结果。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def TreeDepth(self, pRoot):
        if pRoot == None:
            return 0
        leftDepth = self.TreeDepth(pRoot.left)
        rightDepth = self.TreeDepth(pRoot.right)
        return leftDepth + 1 if leftDepth > rightDepth else rightDepth + 1

思路二：层次遍历

层次遍历过程中设置一个变量表示当前层的树的宽度，每次达到最右边一个结点深度加1.变量值变为下一层树的宽度.该方法时间和空间复杂度都为$O(n)$.

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def TreeDepth(self, pRoot):
        if pRoot == None:
            return 0
        queue = []
        queue.append(pRoot)
        depth, count, nextcount = 0, 0, 1
        while queue:
            temp = queue.pop(0)
            count += 1
            if temp.left:
                queue.append(temp.left)
            if temp.right:
                queue.append(temp.right)
            if count == nextcount:
                nextcount = len(queue)
                count = 0
                depth += 1
        return depth       

38. 平衡二叉树

题目描述

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

思路一

先序遍历的思路。判断当前结点的左右子树的高度差是否满足小于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
        return abs(self.depthofTree(pRoot.left)-self.depthofTree(pRoot.right))<=1 
        and self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
    
    def depthofTree(self, pRoot):
        if not pRoot:
            return 0
        leftDepth = self.depthofTree(pRoot.left)
        rightDepth = self.depthofTree(pRoot.right)
        return leftDepth+1 if leftDepth>rightDepth else rightDepth+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
        return self.getDepth(pRoot) != -1
    
    def getDepth(self, pRoot):
        if not pRoot:
            return 0
        l = self.getDepth(pRoot.left)
        if l == -1:
            return -1
        r = self.getDepth(pRoot.right)
        if r == -1:
            return -1
        return -1 if abs(l-r)>1 else max(l+1, r+1)

39. 数组中只出现一次的数字

题目描述

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

思路一：HashMap

基于hashmap的方法，该方法时间复杂度和空间复杂度都为$O(n)$.

# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        count_dict = {}
        for item in array:
            count_dict[item] = count_dict.get(item, 0) + 1
        res = [k for k, v in count_dict.items() if v==1]
        return res[0], res[1]

思路二：异或

首先需要说明的是：异或满足交换律和结合律。因此如果我们用一个0去跟数组中元素一一异或，最后得到的将是两个特殊数的异或值。而得到的异或值至少有一位为1，为1的位置也正是两个特殊数不同的位置。我们可以从低位到高位找到第一个为1的位置，然后依次判断数组中的每一个元素当前位置是否为1来把数组分为两个部分，这样一来两个特殊数必在两个组中（因为两个数当前位置必然不同，一个为0一个为1），而相同的数必被分到同一个组中，然后再对这两个组分别用0进行逐元素异或即可得到要求的两个数。该方法的时间复杂度为$O(n)$，空间复杂度为$O(1)$.

# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        tmp = 0
        for i in array:
            tmp ^= i
        # 找到从低位到高位的第一个1
        flag = 0
        while (tmp & 1) == 0:
            tmp >>= 1
            flag += 1
        # 再次分为两组异或
        a, b = 0, 0
        for i in array:
            if ((i >> flag) & 1) == 0:
                a ^= i
            else:
                b ^= i
        return a, b

40. 和为S的连续正数序列

题目描述

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

思路：双指针法

使用两个指针分别指向连续子序列的第一个a和最后一个数b，则连续子序列和为$\frac{(a+b)\times (b-a+1)}{2}$。如果当前和与所求和相等，则加入到结果中；若当前和小则b自增一次；若当前和大则a自增一次。该方法的时间复杂度为$O(n)$。

# -*- coding:utf-8 -*-
class Solution:
    def FindContinuousSequence(self, tsum):
        # write code here
        low, high = 1, 2
        res = []
        while low < high:
            cursum = (low + high) * (high - low + 1) / 2
            if cursum == tsum:
                res.append(list(range(low, high+1)))
                low += 1
            elif cursum < tsum:
                high += 1
            else:
                low += 1
        return res

41. 和为S的两个数字

题目描述

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。

思路：双指针法

两个指针分别指向数组的头部和尾部向中间夹逼得到结果。这里需要注意的是，相距越远的两个数的乘积越小，因此第一个找到的两个数乘积最小，也就是我们需要求解的值。
证明如下：
设$x+d=y,d>0$,则$x+y=2x+d=C$,其中$C$为常数：
$$x\ast y=x\ast (x+d)=\frac{C-d}{2}\frac{C-d}{2}+d$$
容易证明。

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        i, j = 0, len(array)-1
        res = []
        while i < j:
            csum = array[i] + array[j]
            if csum == tsum:
                res.append(array[i])
                res.append(array[j])
                return res
            elif csum > tsum:
                j -= 1
            elif csum < tsum:
                i += 1
        return res

42. 左旋转字符串

题目描述

本题知识点： 字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

思路

把源字符串视为$XY$，我们要求的即是$YX$，可通过如下方式求解
$$YX=(X^T{Y}^T{)}^T$$
即可通过三次反转来实现。这道题对python不太友好，因为python的字符串是不可变的，需要先把字符串转成list，待操作完成后再转回字符串。时间复杂度为$O(1)$.

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s or n == 0:
            return s
        n = n % len(s)
        s = list(s)
        self.Reverse(s, 0, n-1)
        self.Reverse(s, n, len(s)-1)
        self.Reverse(s, 0, len(s)-1)
        return ''.join(s)
    
    def Reverse(self, s, start, end):
        while start < end:
            temp = s[end]
            s[end] = s[start]
            s[start] = temp
            start += 1
            end -= 1

自带函数解决办法：

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        n = n % len(s)
        return s[n:]+s[:n]

43. 翻转单词顺序列

题目描述

本题知识点： 字符串
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

思路

逐个遍历字符串中的字符，遇到空格后将得到的单词前面加上一个空格放到结果字符串之前并把当前单词置空。遍历结束后若单词不为空则加到结果字符串之前。该方法时间复杂度和空间复杂度均为$O(n)$。

class Solution:
    def ReverseSentence(self, s):
    	# res为结果字符串，tmp为当前单词 
        res, tmp = '', ''
        for i in range(len(s)):
            if s[i] == ' ':
                res = ' ' + tmp + res;
                tmp = ''
            else:
                tmp += s[i]
        if len(tmp) > 0:
            res = tmp + res
        return res

内置函数解决方法：

class Solution:
    def ReverseSentence(self, s):
        return ' '.join(s.split()[::-1]) if s.strip()!='' else s

此外还有一种思路是先将每个单词反转，然后再将整个句子反转。即：
$$X_N{X}_{N-1}...X_1=(X_1^T{X}_2^T...X_N^T{)}^T$$