剑指offer【50~59】

题目链接：

剑指offer 50-59

目录：

50. 第一个只出现一次的字符位置
51. 数组中的逆序对
52. 两个链表的第一个公共结点
53. 数字在排序数组中出现的次数
54. 二叉查找树的第 K 个结点
55.1 二叉树的深度
55.2 平衡二叉树
56. 数组中只出现一次的数字
57.1 和为 S 的两个数字
57.2 和为 S 的连续正数序列
58.1 翻转单词顺序列
58.2 左旋转字符串
59. 滑动窗口的最大值

Python 实现：

50. 第一个只出现一次的字符位置

使用大小为 256 的数组记录每个字符出现的次数。遍历两遍即可。

# -*- coding:utf-8 -*-
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        dic = [0] * 256
        for i in range(len(s)):
            dic[ord(s[i])] += 1
        for i in range(len(s)):
            if dic[ord(s[i])] == 1:
                return i
        return -1
51. 数组中的逆序对
  • 常规方法 O(n^2)，先 pass。可以使用归并排序的思想，在归并的过程中统计逆序对的数量。
  • 比如在归并过程中，left = [1,3,5,7,9]，right = [2,4,6,8,10]，发现 3 > 2，则 left[1:] 的所有数都比 right[0] 大，就累加逆序对数量，后面的也同理。
  • 详情可以参考博客 剑指Offer（三十五）：数组中的逆序对
  • 这样时间复杂度为 O(nlogn)，空间复杂度为 O(n)。但是 Python 卡了一下时间，AC 了 75%。
# -*- coding:utf-8 -*-
class Solution:
    def InversePairs(self, data):
        # write code here
        self.ans = 0  # 逆序对数量
        self.mergeSort(data)   # 归并排序
        return self.ans % 1000000007
    
    def mergeSort(self, nums):
        # 递归过程
        if len(nums) <= 1:
            return nums
        mid = len(nums) // 2
        left = self.mergeSort(nums[:mid])
        right = self.mergeSort(nums[mid:])
        return self.merge(left, right)

    # 归并过程 + 统计逆序对数量
    def merge(self, left, right):
        result = []  # 保存归并后的结果
        i = j = 0
        left_len = len(left)
        while i < len(left) and j < len(right):
            if left[i] <= right[j]:
                result.append(left[i])
                i += 1
            else:  # left[i] > right[j]
                self.ans += (left_len - i)  # 核心：说明 nums[i:] 都大于 nums[j]
                result.append(right[j])
                j += 1
        result = result + left[i:] + right[j:] # 剩余的元素直接添加到末尾
        return result
52. 两个链表的第一个公共结点
  • 设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。
  • 当访问链表 A 的指针 L1 访问到链表尾部时，令它从链表 B 的头部重新开始访问链表 B；同样地，当访问链表 B 的指针 L2 访问到链表尾部时，令它从链表 A 的头部重新开始访问链表 A。这样就能控制 L1 和 L2 能同时访问到公共结点。即 L1 总共走了 (a + c) + b，L2 总共走了 (b + c) + a。
  • 这样，链表 A 和链表 B 都走了 a + b + c 步，时间复杂度为 O(n)，空间复杂度为 O(1)。
# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def FindFirstCommonNode(self, pHead1, pHead2):
        # write code here
        l1, l2 = pHead1, pHead2
        while l1 != l2:
            l1 = l1.next if l1 != None else pHead2
            l2 = l2.next if l2 != None else pHead1
        return l1 # 或者 l2
53. 数字在排序数组中出现的次数

排序数组，很明显二分查找，找到第一个 >= k 的元素索引以及第一个 > k 的元素索引，两者相减即为答案，即 lowerBound - upperBound。时间复杂度为 O(logn)，空间复杂度为 O(1)。

# -*- coding:utf-8 -*-
class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        if not data:
            return 0
        lo, hi = 0, len(data) - 1
        while lo < hi:
            mid = lo + (hi - lo) // 2
            if data[mid] >= k:
                hi = mid
            elif data[mid] < k:
                lo = mid + 1
        ind1 = lo if data[lo] >= k else len(data)  # >=k 的第一个元素
        lo, hi = 0, len(data) - 1
        while lo < hi:
            mid = lo + (hi - lo) // 2
            if data[mid] > k:
                hi = mid
            elif data[mid] <= k:
                lo = mid + 1
        ind2 = lo if data[lo] > k else len(data)  # # >k 的第一个元素
        return ind2 - ind1  # 相减即为答案

更简洁的，可以使用 Python 的 bisect 模块中的函数实现。可以参考博客：二分查找及其变形与Python的bisect模块的关系。

# -*- coding:utf-8 -*-
import bisect
class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        return bisect.bisect_right(data, k) - bisect.bisect_left(data, k)
54. 二叉查找树的第 K 个结点

中序遍历，找到第 k 个数即可。

#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回对应节点TreeNode
    def __init__(self):
        self.cnt = 0
        
    def KthNode(self, pRoot, k):
        # write code here
        if not pRoot or self.cnt >= k:  # self.cnt >= k 剪枝
            return None
        left = self.KthNode(pRoot.left, k)
        if left:
            return left
        self.cnt += 1
        if self.cnt == k:
            return pRoot
        right = self.KthNode(pRoot.right, k)
        if right:
            return right
        return None
55.1 二叉树的深度

递归左右子树找最大高度。注意：根的高度为 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):
        # write code here
        if not pRoot:
            return 0
        return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right)) + 1
55.2 平衡二叉树

平衡二叉树（AVL）的左右子树的高度差不超过 1，因此引入求高度的函数。并且，判断该树的每个结点的左右子树是否也满足 AVL 的定义。

# -*- 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
        if abs(self.TreeDepth(pRoot.left) - self.TreeDepth(pRoot.right)) > 1:  # 不满足 AVL 的定义
            return False
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
        
    def TreeDepth(self, pRoot):
        if not pRoot:
            return 0
        return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right)) + 1

改进：自顶向下在调用求树的高度的函数时，有很多重复的操作。因此，可以使用自底向上的方法，一边计算树的高度，一边判断是否是 AVL 树。

# -*- 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
        self.isBalance = True
        self.TreeDepth(pRoot)  # 在求树的高度过程中判断 AVL
        return self.isBalance
        
    def TreeDepth(self, pRoot):
        if not pRoot:
            return 0
        left = self.TreeDepth(pRoot.left)
        right = self.TreeDepth(pRoot.right)
        if abs(left - right) > 1:   # 不满足 AVL 定义，修改 self.isBalance 的值
            self.isBalance = False
        return max(left, right) + 1
56. 数组中只出现一次的数字

如果只出现一次的数字只有一个，很好做，就是全部异或即可。但是，只出现一次的数字有两个怎么做呢？

  • 假设只出现一次的数字为 x 和 y，首先，还是先全部异或得到一个结果 xor，则 x ^ y = xor（相同的数字异或后抵消为 0）
  • 因为 x 和 y 肯定不同，那么它们的二进制表示中肯定有一位一个是 0， 一个是 1。比如 x = 6 (110)，y = 4 (100)，xor = 2 (10)，则我们对 xor 从后往前找到倒数第一个 1 的位置 bits（倒数第 2 位），则以这个 1 为界限，x 和 y 的倒数第 2 位肯定是不同。
  • 因此，对原来的数组重新异或，将 bits 位置为 1 的全部异或，bits 为 0 的全部异或，就是最终的两个返回的结果。
# -*- coding:utf-8 -*-
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        xor = 0
        ans = [0, 0]
        for num in array:
            xor ^= num
        bits = 0  # 找到倒数第 i 位为 1
        while xor & 1 << bits == 0:
            bits += 1
        for num in array:
            if num >> bits & 1 == 1:  # num 的倒数第 i 位为 1
                ans[0] ^= num
            else:  # num 的倒数第 i 位为 0
                ans[1] ^= num
        return ans
57.1 和为 S 的两个数字

双指针指向首尾，往中间走，碰到第一对和为 S 的就是答案。

# -*- coding:utf-8 -*-
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        lo, hi = 0, len(array) - 1
        while lo < hi:   # 不能指向相同的数字
            if array[lo] + array[hi] == tsum:
                return [array[lo], array[hi]]
            elif array[lo] + array[hi] < tsum:
                lo += 1
            else:
                hi -= 1
        return []
57.2 和为 S 的连续正数序列

经典的滑动窗口例题，只不过该题的窗口大小不确定。用一个遍历 left 记录窗口左侧的值，window_sum 将窗口中数进行累加。当发现 window_sum >= S 时，相等时输出结果，更新 left 和 window_sum。

# -*- coding:utf-8 -*-
class Solution:
    def FindContinuousSequence(self, tsum):
        # write code here
        if tsum <= 1:  # 特殊情况
            return []
        ans = []
        left, window_sum = 1, 0  # left 记录窗口左界
        for i in range(1, (tsum + 1) // 2 + 1):  # 窗口中至少两个数
            window_sum += i  # 窗口中的累加和
            while window_sum >= tsum:
                if window_sum == tsum:  # 输出一组结果
                    ans.append([j for j in range(left, i + 1)])
                window_sum -= left  # 修改窗口中的累加和
                left += 1  # 修改窗口的左界
        return ans
58.1 翻转单词顺序列

如果要求空间复杂度为 O(1)，即只能使用字符串本身，该怎么操作呢？

  • 如 s = "I am a student."，先将各个单词翻转，得 s = ".tneduts a ma I"；
  • 再将整个字符串翻转，得 s = "student. a am I"

这样就可以在字符串本身上做修改，使得空间复杂度为 O(1) 了。

注意：但是使用 Python 实现得话，由于不能修改字符串本身，所以还是先要将字符串转化为列表。但是如果使用 C++ 的字符数组，就不用开辟空间了。

# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        def reverseWord(s, i, j):
            while i < j:
                s[i], s[j] = s[j], s[i]
                i += 1
                j -= 1
        
        s = list(s)  # python 中 s 不能修改，先转化为 list 
        start = 0  # start 指向当前单词的起始位置
        lens = len(s)
        for i in range(lens + 1):
            if i == lens or s[i] == ' ':
                reverseWord(s, start, i - 1) # 先翻转每个单词
                start = i + 1  # 下一个单词的起始位置
        reverseWord(s, 0, lens - 1)  # 再将整个句子翻转
        return "".join(s)
58.2 左旋转字符串

如果也不能使用空间，怎么做呢？参考上面的 58.1，如 s = "abcXYZdef"，n = 3，先将 "abc" 和 "XYZdef" 分别翻转，得到 "cbafedZYX"，然后再把整个字符串翻转得到 "XYZdefabc"。这样就可以空间复杂度为 O(1) 了。

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        def reverseWord(s, i, j):
            while i < j:
                s[i], s[j] = s[j], s[i]
                i += 1
                j -= 1
        
        if not s:
            return ""
        s = list(s)
        lens = len(s)
        n %= lens  # 循环左移
        reverseWord(s, 0, n - 1)  # 先将前 n 个字符翻转
        reverseWord(s, n, lens - 1)  # 再将后面的字符翻转
        reverseWord(s, 0, lens - 1)  # 最后将整个字符串翻转
        return "".join(s)  # 再转化回字符串
59. 滑动窗口的最大值

使用双向递减队列，队列中始终维护的是窗口中的递减值。

  • 如果队列的大小达到了 size，则应该把队列最前面的数字删除掉。
  • 如果从最右边加入了一个较大的数字，需要从右开始退队列（while 循环），使得队列是单调递减的。
  • 由于双向队列中，从左边出队列和从右边出队列的操作时间复杂度均为 O(1)，因此该算法的时间复杂度为 O(n)，空间复杂度为 O(n)。

例如，num = [2,3,4,2,6,2,5,1]，size = 3，双向队列的变化情况为 dq： [2] -> [3] -> [4] -> [4,2] -> [6] (6 比 2 和 4 都大) -> [6,2] -> [6,5] (5 比 2 大) -> [5,1] (6 超出窗口，从队列首部出队)。

# -*- coding:utf-8 -*-
import collections
class Solution:
    def maxInWindows(self, num, size):
        # write code here
        if size > len(num) or size < 1:
            return []
        dq = collections.deque()  # [num[i], i]
        ans = []
        for i in range(len(num)):
            if dq and i - dq[0][1] >= size:
                dq.popleft()  # O(1)
            while dq and num[i] > dq[-1][0]: # 从后往前删除比 num[i] 大的数
                dq.pop()  # O(1)
            dq.append([num[i], i])
            if i >= size - 1:
                ans.append(dq[0][0])  # 队列首部始终最大
        return ans

剑指 offer 终于过了一遍，大多数题目还是很简单的，但是题目具有代表性，涉及链表、数组、深搜回溯、字符串、数组、数学、位运算、动态规划等。这里做一个总结：

剑指offer【03~09】
剑指offer【10~19】
剑指offer【20~29】
剑指offer【30~39】
剑指offer【40~49】
剑指offer【50~59】
剑指offer【60~68】

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,560评论 4赞 361
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,104评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,297评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,869评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,275评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,563评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,833评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,543评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,245评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,512评论 2赞 244
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,011评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,359评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,006评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,062评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,825评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,590评论 2赞 273
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,501评论 2赞 268