python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第1张图片

目录

33.丑数
34.第一个只出现一次的字符
35.数组中的逆序对
36.两个链表的第一个公共结点
37.数字在排序数组中出现的次数
38.二叉树的深度
39.平衡二叉树
40.数组中只出现一次的数字
41.和为S的连续正数序列
42.和为S的两个数字
43.左旋转字符串
44.翻转单词顺序列
45.扑克牌顺子
46.孩子们的游戏(圆圈中最后剩下的数)
47.求1+2+3+...+n
48.不用加减乘除做加法
49.把字符串转换成整数
50.数组中重复的数字
51.构建乘积数组
52.正则表达式匹配
53.表示数值的字符串
54.字符流中第一个不重复的字符
55.链表中环的入口结点
56.删除链表中重复的结点
57.二叉树的下一个结点
58.对称的二叉树
59.按之字形顺序打印二叉树
60.把二叉树打印成多行
61.序列化二叉树
62.二叉搜索树的第k个结点
63.数据流中的中位数
64.滑动窗口的最大值
65.矩阵中的路径
66.机器人的运动范围
67.剪绳子

33.丑数

把只包含质因子2、3和5的数称作丑数(Ugly Number)。例如6、8都是丑数,但14不是,因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

思路:

先看一下前几个丑数都是怎么得到的:

  • 第一个丑数是1,
  • 下一个丑数为min(1x2, 1x3, 1x5),
  • 再下一个丑数为min(2x2, 1x3, 1x5),
  • 再下一个丑数为min(2x2, 2x3, 1x5)

让我们总结一下规律:

所有的丑数都是等于2 x i, 3 x i, 5 x i。其中 i 是丑数list中的元素

一开始丑数只有1。每次丑数从2 x i, 3 x i, 5 x i中选取最小的。假设当前丑数是2 x i, 那么需要更新i,和2相乘的i变成丑数序列的下一个元素,进入下一轮比较。和3相乘的i与和5相乘的i不变。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第2张图片
紫色是需要更新i的位置,即选取当前数作为丑数,追加到丑数序列中
class Solution:
    def GetUglyNumber_Solution(self, index):
        if index == 0:
            return 0
        res = [1]
        i2, i3, i5 = 0, 0, 0
        i = 1
        while i < index:
            res.append(min(res[i2]*2, res[i3]*3, res[i5]*5))
            if res[-1] == res[i2]*2:
                i2 += 1
            if res[-1] == res[i3]*3:
                i3 += 1
            if res[-1] == res[i5]*5:
                i5 += 1
            i += 1
        return res[-1]

34.第一个只出现一次的字符

在一个字符串(0<=字符串长度<=10000,全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1(需要区分大小写).

思路:

  • 首先遍历一次s,用一个dic存储每一个字符出现次数,key为Ascii码,值为出现次数
  • 然后再遍历一次s,看dic中当前字符是否出现次数为1次,是的话返回当前字符index,否则返回-1即可!
  • 注意判断不满足条件的情况,字符长度为0,或者每个字符都出现了超过1次~
class Solution:
    def FirstNotRepeatingChar(self, s):
        if not s:
            return -1
        dic = [0]*256
        for i in s:
            dic[ord(i)] +=1 
        for i in range(len(s)):
            if dic[ord(s[i])] == 1:
                return s.index(s[i])
                break
            elif i == len(s)-1 and dic[ord(s[i])] > 1:
                return -1

35.数组中的逆序对

在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007

输入描述:

题目保证输入的数组中没有的相同的数字
数据范围:
	对于%50的数据,size<=10^4
	对于%75的数据,size<=10^5
	对于%100的数据,size<=2*10^5

输入:

1,2,3,4,5,6,7,0

输出:

7

思路:

这题属于归并排序的变形题目。首先回顾一下归并排序~经典的分治思想:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第3张图片
图片来自网络

分的阶段,被分到一组的两个数之间就可以比较是否是逆序对,记录逆序对数目;

治的阶段,用两个指针指向数对的末尾,用一个辅助数组存储排序结果:

如果p1指向的数字大于p2指向的数字,则意味着逆序对成立,并且逆序对的数目等于第二个子数组中剩余数字的个数,因为p2指向数字是第二个子数组中最大的了,而p1指向数字比第二个数组最大的还大,所以对第二个数组来说,每个数字都和当前p1指向数字构成逆序对。

每次都将比较较大的数字复制到辅助数组中,并且对应的指针前进1位。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第4张图片
class Solution:
    def __init__(self):
        self.count = 0
        
    def mergeSort(self, data):
        if len(data) < 2: return data
        mid = len(data)//2
        left = self.mergeSort(data[:mid])
        right = self.mergeSort(data[mid:])
        i, j = 0, 0
        res = []
        while i < len(left) and j < len(right):
            if left[i] <= right[j]:
                res.append(left[i])
                i += 1
            else:
                res.append(right[j])
                j += 1
                self.count += (len(left)-i)
        return res + left[i:] + right[j:]
        
    def InversePairs(self, data):
        if len(data) < 2: return 0
        self.mergeSort(data)
        return self.count % 1000000007

36.两个链表的第一个公共结点

输入两个链表,找出它们的第一个公共结点。(注意因为传入数据是链表,所以错误测试数据的提示是用其他方式显示的,保证传入数据是正确的)

思路:

思路很简单~拥有公共节点的链表是Y型,大概长这个样子:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第5张图片
可以看到,后面都是公共结点。

我们可以将两个链表每个结点分别压入两个栈s1, s2内,再一起pop。

判断pop元素是否相同,当遇到不同的结点,那么上一个pop出去的节点就是第一个公共结点。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第6张图片
所以4就是第一个公共节点
class Solution:
    def FindFirstCommonNode(self, h1, h2):
        s1, s2 = [], []
        p1, p2 = h1, h2
        while p1:
            s1.append(p1)
            p1 = p1.next
        while p2:
            s2.append(p2)
            p2 = p2.next
        res = []
        while s1 and s2:
            node1 = s1.pop()
            node2 = s2.pop()
            if node1 == node2:
                res.append(node1)
        if res:
            return res[-1]
        else:
            return None

37.数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

思路:

骚操作:data.count(k)

正常思路:二分查找,然后从查找到的这个点前后遍历,找到一共有多少个该数字。

巧妙思路:某位道友提供的思想!简直太妙,学习到了!

因为data中都是整数,所以可以稍微变一下,不是搜索k的两个位置,而是搜索k-0.5和k+0.5这两个数应该插入的位置,然后相减即可。
class Solution:
    def bin_search(self, data, k):
        low = 0
        high = len(data) - 1
        while low <= high:
            mid = int((high - low)/2 +low)
            print(low, mid, high)
            if data[mid] < k:
                low = mid + 1
            elif data[mid] > k:
                high = mid - 1
        return low # low位置就是要插入的index
    def GetNumberOfK(self, data, k):
        return self.bin_search(data, k+0.5) - self.bin_search(data, k-0.5) # 高位index - 低位index

这里需要注意,要返回的是low的位置,因为最后low = high的时候还要判断一下data[mid] 和k之间的大小关系:

  • 假设data[mid]< k, 说明下一个位置才是需要插入的index;
  • 假设data[mid]> k, 说明当前位置合适。

38.二叉树的深度

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

思路:

又回到递归了,回想递归思路:当所有子问题都已经完美解决,最后一步需要干什么?

这道题里,假设所有子问题已经完美解决,就是已经计算出了左子树和右子树的高度,那么最后一步我们只要取左子树和右子树中间比较大的深度,再加1,即根节点的深度,就是最终二叉树的深度了。

class Solution:
    def TreeDepth(self, pRoot):
        if not pRoot:
            return 0
        if pRoot and not pRoot.left and not pRoot.right:
            return 1
        return 1 + max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right))

39.平衡二叉树

输入一棵二叉树,判断该二叉树是否是平衡二叉树。在这里,我们只需要考虑其平衡性,不需要考虑其是不是排序二叉树。

思路:

首先什么是平衡二叉树?来自维基百科的定义:

AVL树是最早被发明的自平衡二叉查找树。在AVL树中,任一节点对应的两棵子树的最大高度差为1,因此它也被称为 高度平衡树

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第7张图片

很容易想到,这道题也可以用递归实现~

假设左右子树已经判断完毕,我们只需要判断根节点左右子树高度差是否<=1,以及左右子树是否也为AVL树即可~

如何求树的高度,上一题已经给出解决办法!直接套用即可:

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

但是!问题来了!这里从上往下判断,在判断上层结点的时候,会多次重复遍历下层结点。我们其实可以在计算树的深度的过程中就进行判断,是否左右子树高度差小于等于1,如果不是的话就可以直接返回False。

class Solution:
    def __init__(self):
        self.res = True
    def TreeDepth(self, pRoot):
        if not pRoot:
            return 0
        if not self.res:
            return 1
        left = self.TreeDepth(pRoot.left) + 1
        right = self.TreeDepth(pRoot.right) + 1
        if abs(left - right) > 1:
            self.res = False
        return max(left, right)
    def IsBalanced_Solution(self, pRoot):
        self.TreeDepth(pRoot)
        return self.res

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

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

思路:

简单的思路:用一个dict存储数字以及对应出现的次数。

膜拜大神的思路:

由于这题的特殊性,有两个数字出现了一次,其余所有数字出现了两次。可以利用这个性质进行位运算

首先我们思考一个本题的简化版本:假设只有一个数字出现了一次,其余所有数字出现了两次。那么由于异或的性质:

同样的数字异或结果为0,任何数字与0异或结果为它本身。

利用这个性质,简化版本的问题只要对数组中每个数字进行异或,就可以得到只出现一次的数字。

对于本题,有2个只出现了1次的数字。那么对数组中每个数字进行异或,得到的结果就是这两个数字的异或结果这个结果的二进制中的1,表现的是A和B的不同的位。取第一个1所在的位置,将原数组划分成两个数组。(如下图中的第4位)

分组依据就是该位置是否为1。相同的数肯定在一个组,因为相同数字所有位都相同,而不同的数则不在一组。这样我们就可以将这两个数分开。然后对分组结果做异或,就可以得到这两个只出现一次的数字了!!!

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第8张图片
这里分组位置在第4位

实现上:

  • 先用isBit函数判断某数字index位置是否为1,然后通过对array每个元素异或结果得到index。
  • 再次遍历array,判断当前数字index位置是否为1,是的话和a做异或,反之与b做异或。得到a和b。(避免了开辟空间存储两个数组)
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def isBit(self, data, index):
        # 判断数字data的index位置是否为1
        data = data >> index
        return data & 1
    def FindNumsAppearOnce(self, array):
        xor_res = 0
        for i in array:
            xor_res ^= i
        index = 0
        while (xor_res & 1) == 0:
            xor_res >>= 1
            index += 1
        a, b = 0, 0
        for i in array:
            if self.isBit(i, index):
                a ^= i
            else:
                b ^= i
        return [a, b]

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

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

思路:

这题有一个比较巧妙的思路~ 也是参考了牛客网大神的思路!在这里继续给大家的奇思妙想鞠躬,奇怪的知识增加了!

我们利用两个指针,一个左边left,一个右边right指向这个连续正数序列的首尾两个元素。然后sum是首与尾之间所有元素之和。初始化left=1, right=2:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第9张图片
  • 当sum大于targetsum的时候,我们从序列中减去较小的那个数字left,并且left+1,即低位窗口向右滑动一位;
  • 当sum小于targetsum的时候,我们将right向右移动一位,再将sum加上较大的那个数字,即高位窗口向右滑动一位;
  • 当sum等于targetsum的时候,将当前序列加入result中。

由于至少有两个连续元素,所以left一定小于right,这是循环停止条件:

class Solution:
    def FindContinuousSequence(self, tsum):
        left, right = 1, 2
        sum, res = 3, []
        while left < right:
            if sum > tsum:
                sum -= left
                left += 1
            else:
                if sum == tsum:
                    res.append([i for i in range(left, right + 1)])
                right += 1
                sum += right
        return res

42.和为S的两个数字

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

思路:

考虑用两个指针代表前后两个数字,依次向中间靠拢寻找答案!

为什么要从两边向中间靠拢寻找答案呢?由于题目要求,如果答案存在多对,要输出乘积最小的。这里需要证明一下,外层乘积小于内层乘积~

证明:

假设存在a,b两个数, 其和为a+b。 那么存在m>0, 满足(a-m) + (b+m) = a + b; (a - m)*(b + m) = ab + am - bm - m^2 = ab -(b-a)m - m^2; 由于b-a >0, 所以(a - m)*(b + m) = ab + am - bm - m^2 = ab -(b-a)m - m^2 所以外层乘积小于内层乘积得证。

用两个指针代表前后两个数字的索引,left和right:

  • left位置元素与right位置元素之和小于sum,说明两数之和小了,left右移寻找更的数;
  • left位置元素与right位置元素之和大于sum,说明两数之和大了,right左移寻找更的数;
  • left位置元素与right位置元素之和相等,返回array[left]与array[right]。
class Solution:
    def FindNumbersWithSum(self, array, tsum):
        if not array:
            return []
        left = 0
        right = len(array) - 1
        while left < right:
            if array[left] + array[right] < tsum:
                left += 1
            if array[left] + array[right] > tsum:
                right -= 1
            if array[left] + array[right] == tsum:
                return [array[left] , array[right]]
        return []

43.左旋转字符串

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

思路:

敲黑板!!熟练运用python的切片

class slice(start, stop[, step])
start -- 起始位置
stop -- 结束位置
step -- 间距
class Solution:
    def LeftRotateString(self, s, n):
        return s[n:]+s[0:n]

44.翻转单词顺序列

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

思路:

和上题一样!必须熟练运用python的切片!由于切片属性,反转的数组是array[::-1]

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

45.扑克牌顺子

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)...他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿!!“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子.....LL不高兴了,他想了想,决定大小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何, 如果牌能组成顺子就输出true,否则就输出false。为了方便起见,你可以认为大小王是0。

思路:

一个比较笨的思路:由于0代表任意数,对数组进行排序,从小到大,0排在前面。那么0的数目是ct_0。假设后面不为0的两个连续数字之差大于1,即没有连上顺子,那么中间的差值需要用0补齐,差多少个数字就需要多少个0。

  • 当ct_0为负数时,说明补不齐,返回False;
  • 注意当出现两个一样的数字,意思是存在对子,那么一定不存在顺子,返回False。
class Solution:
    def IsContinuous(self, numbers):
        if not numbers:
            return False
        numbers = sorted(numbers)
        ct_0 = 0
        for i in range(4):
            if numbers[i] == 0:
                ct_0 += 1
            else: 
                if numbers[i+1] - numbers[i] > 1:
                        ct_0 -= (numbers[i+1] - numbers[i] - 1)
                if  numbers[i+1] - numbers[i] == 0:
                    return False
                if ct_0 < 0:
                    return False
        return True

另一个解答区的巧妙思路:

由于顺子特性,最大值与最小值相差<5;
最大值最小值都不包含0;
除0之外没有重复数字;

这样就避免了模拟用0填充差值这一步~巧妙!具体的实现比较简单就不贴啦~

46.孩子们的游戏(圆圈中最后剩下的数)

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0...m-1报数....这样下去....直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_^)。请你试着想下,哪个小朋友会得到这份礼品呢?(注:小朋友的编号是从0到n-1)。如果没有小朋友,请返回-1。

思路:

这题是经典的约瑟夫环问题!我们可以通过模拟这个过程来得到结果:

从索引为0的小朋友开始数, 第一次需要出列是数到m-1的小朋友,由于可能存在m-1大于n的情况,所以index为(m-1)%n。下一个开始的小朋友,索引位置就是刚刚pop出去的索引值。

假设m=5, n=10:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第10张图片
模拟了两次pop过程
class Solution:
    def LastRemaining_Solution(self, n, m):
        if not m or not n:
            return -1
        res = [i for i in range(n)]
        i = 0
        while len(res) > 1:
            i = (m - 1 + i) % len(res)
            res.pop(i)
        return res[0]

第二种思路就是归纳法得到对应数:

假设孩子们排成一个圈,序号从0到n-1:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第11张图片

第一个出去的孩子序号为 (m-1)%n

剩下的孩子们的序号:0,1,2,m-3, m-2, ,m, m+1, ..., n-2, n-1

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第12张图片
橙色位置出队

第二轮从m开始数,此时的m重新拍号,从0开始,整个过程如下:

  • 上一轮最后:0,1,2,m-3, m-2, m, m+1, ..., n-2, n-1
  • 转换一下(此时index假设为x):m, m+1, ... , n-2, n-1,0,1,2,m-3, m-2
  • 这一轮开始(此时index假设为y):0,1,2,3,...,n-3, n-2

那么重新排号之后,x和y的对应关系:

y = (x - M + N) % N    (1)
x = (y + M) % N      (2)

出列1人之后,剩下n-1人,继续这个重排序,并且出列的过程。

当只剩下1个人的时候,编号为0,这个人出列。假设存在函数F(·),那么

F(1) = 0

根据(2), 此时N=2,有:

F(2) = [F(1) + M] % N = [F(1) + M] % 2

再往前推,此时N=3,有:

F(3) = [F(2) + M] % N = [F(2) + M] % 3

总结规律:

F(1) = 0
F(N) = [F(N - 1) + M] % N      (当N>1时)

有了规律就可以通过递推实现~

class Solution:
     def LastRemaining_Solution(self, n, m):
        if n < 1 or m < 1:
            return -1
        last = 0 #n=1
        for i in range(2, n + 1):
            last = (last + m % i) % i
        return last

47.求1+2+3+...+n

求1+2+3+...+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。

思路:

经典短路求值+递归。python种的a and b,当a为假时返回a,当a为真时返回b.

由于短路特性,从n到1,n一直为真,所以会持续返回n+n-1+n-2...+2+1

class Solution:
    def Sum_Solution(self, n):
        return n and (n + self.Sum_Solution(n-1))

48.不用加减乘除做加法

写一个函数,求两个整数之和,要求在函数体内不得使用+、-、*、/四则运算符号。

思路:

这题也考虑使用位运算来实现~

假设计算9+3, 按照二进制9:1001, 3:0011

  • 按位与,并且左移一位,补0,当两位都是1的时候返回1,按位与是用于计算进位位n1;

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第13张图片
  • 按位异或,当两位不同的时候返回1,这种情况是计算非进位位n2;

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第14张图片
  • n1 & n2可以查看是否还有进位位,如果有的话,重复上述过程,直到没有进位位为止。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第15张图片
还有进位位,继续前面两步

注意,由于python没有位数限制,不会把负数的最高位1当作符号位,所以我们上面的结果需要进行越界检查~

class Solution:
    def Add(self, num1, num2):
        while  num2: # num2意味着还有进位
            num1, num2 = (num1 ^ num2) & 0xffffffff, ((num1 & num2) << 1) & 0xffffffff
        if num1 <= 0x7fffffff:
            result = num1
        else:
            result = ~(num1^0xffffffff)
        return result

这里代码简化了一点,直接判断是否还有进位,没有用到n1&n2判断,是因为进位位的计算已经是(n1&n2) << 1,所以可以直接用n2当作判断条件,即是否还有进位。

49.把字符串转换成整数

将一个字符串转换成一个整数,要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0

输入描述:

输入一个字符串,包括数字字母符号,可以为空

输出描述:

如果是合法的数值表达则返回该数字,否则返回0

思路:

  • 用一个符号位判断是正数还是负数;
  • 用一个table存数字字符 table = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
  • 从后往前判断,是否在table中,不是的话返回0;
  • 每个字符在table里面寻找对应索引值,这个索引就是它对应的值,然后将索引和10^(index-1)相乘,和之前的num累加;
  • 判断到第一个字符,要确认一下是‘+','-'还是数字,如果是'+', '-'修改符号位。
class Solution:
    def StrToInt(self, s):
        table = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
        res = 0
        for i in range(1,len(s)+1):
            if i == len(s) and s[-i] == '+':
                return res
            if i == len(s) and s[-i] == '-':
                return -res
            if s[-i] not in table:
                return 0
            res += table.index(s[-i])*10**(i-1)
        return res

50.数组中重复的数字

在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的,但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如,如果输入长度为7的数组{2,3,1,0,2,5,3},那么对应的输出是第一个重复的数字2。

思路:

创建一个长度为len(numbers)的数组num,初始化每个元素都为0。然后由于数组里的所有数字都在0到n-1的范围内,所以numbers里的每个数字i都可以用作索引,即num[i],用于存储i元素出现次数。

  • 如果num[i]为0,说明该元素目前出现1次,num[i]就增加1;
  • 如果num[i]不为0,说明该元素目前出现超过1次,可以将该元素返回。
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        num = [0]*len(numbers)
        for i in numbers:
            if num[i] == 0:
                num[i] += 1
            else:
                duplication[0] = i
                return True
        return False

51.构建乘积数组

给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。(注意:规定B[0] = A[1] * A[2] * ... * A[n-1],B[n-1] = A[0] * A[1] * ... * A[n-2];)

思路:

这题比较巧妙的解法是参考剑指offer上面对乘积数组的构建图示:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第16张图片
图片源自网络

可以将乘积数组B的组成看作由1分割成上下两部分三角型数组的每行元素乘积组成。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第17张图片

用Up和Down储存上下两个三角形的元素乘积。

对于Down来说,存在Down[i-1] = A[i] * Down[i]关系,推导如下:

Down[0] = 1
Down[1] = A[0] * 1 = A[0] * Down[0]
Down[2] = A[1] * A[0] * 1 = A[1] * Down[1]
Down[3] = A[2] * A[1] * A[0] * 1 = A[2] * Down[2]
...
Down[i+1] = A[i] * Down[i]

对于Up来说,Up是个倒三角形,所以由下向上计算。存在

Up[0] = 1
Up[1] = A[-1] * 1 = A[-1] * Up[0]
Up[2] = A[-2] * A[-1] * 1 = A[-2] * Up[1]
Up[3] = A[-3] * A[-2] * A[-1] * 1 = A[-3] * Up[2]
...
Up[i+1] = A[-i-1] * Up[i]

这样B的每个元素B[i]就是Up的尾部元素Up[-i-1]乘以Down的头部元素Down[i]:

class Solution:
    def multiply(self, A):
        if not A:
            return []
        D = [1]
        U = [1]
        for i in range(len(A) - 1):
            D.append(D[i] * A[i])
            U.append(U[i] * A[-i-1])
        B = [D[i] * U[-i-1] for i in range(len(A))]
        return B

52.正则表达式匹配

请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符,而'*'表示它前面的字符可以出现任意次(包含0次)。 在本题中,匹配是指字符串的所有字符匹配整个模式。例如,字符串"aaa"与模式"a.a"和"ab*ac*a"匹配,但是与"aa.a"和"ab*a"均不匹配。

思路:

这里s和pattern都不为空的情况比较好考虑,需要多注意s和pattern存在为空的情况~

  • 首先,存在一种情况,pattern的第一个字符不管是什么,第二个字符是*,这就代表着第一个字符可能存在0次,即 char*这个情况:
    • 假设s[0] != pattern[0], 那么我们可以把pattern后移两位继续判断,这就是让pattern第一个字符出现0次(这里pattern第一个字符不可以是'.')。比如s=jsffff, pattern=q*s.ss,j!=q,那么pattern后移两位,从s.ss开始判断;
    • 假设s[0] == pattern[0],并且pattern[1]是 *,这个时候又可以分成三种情况
  1. pattern不变,s后移一位,因为pattern中的*可以匹配多位;
  2. pattern后移2位,s不变,相当于把pattern前两位当成空,略过前两位;
  3. pattern后移2位,s后移1位,相当于pattern前2位与s[0]匹配。
  • 当pattern第二个字符不为*的情况:
  • 如果s[0] == pattern[0]或者pattern[0] == '.',s和pattern都后移一位
  • 否则返回False
  • 剩余的情况就是s或者pattern某个为空的时候
  • 假设s和pattern都为空,返回True;
  • 假设s不为空,pattern为空,返回False;
  • 假设s为空,pattern不为空,则需要判断: 如果pattern的第二个字符是*,pattern后移2位继续判断。否则返回False。
# -*- coding:utf-8 -*-
class Solution:
    # s, pattern都是字符串
    def match(self, s, pattern):
        if len(s) == 0 and len(pattern) == 0:
            return True
        elif len(s) != 0 and len(pattern) == 0:
            return False
        elif len(s) == 0 and len(pattern) != 0:
            if len(pattern) > 1 and pattern[1] == '*':
                return self.match(s, pattern[2:])
            else:
                return False
        else:
            if len(pattern) > 1 and pattern[1] == '*':
                if s[0] != pattern[0] and pattern[0] != '.':
                    return self.match(s, pattern[2:])
                else:
                    return self.match(s, pattern[2:]) or self.match(s[1:], pattern[2:]) or self.match(s[1:], pattern)
            else:
                if s[0] == pattern[0] or pattern[0] == '.':
                    return self.match(s[1:], pattern[1:])
                else:
                    return False

53.表示数值的字符串

请实现一个函数用来判断字符串是否表示数值(包括整数和小数)。例如,字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。

思路:

让我们开始仔细审题,看看给出的反例:

  • 12e:e的后面必须有数字;
  • 1a3.14:不能有除了e/E之外的其它字母;
  • 1.2.3:不能有多个小数点;
  • +-5:只能有1个符号位;
  • 12e+4.3:e后面不能有小数点;

这样如果用if else方式判断可能会比较多情况,可以考虑用正则表达式

re?匹配0个或1个由前面的正则表达式定义的片段,非贪婪方式;
[...]用来表示一组字符,单独列出:[amk] 匹配 'a','m'或'k';
re*匹配0个或多个的表达式;
[0-9]匹配任何数字。类似于 [0123456789];
re+匹配1个或多个的表达式。
class Solution:
    # s字符串
    def isNumeric(self, s):
        import re
        a = re.match(r"[+-]?[0-9]*(.[0-9]*)?([eE][+-]?[0-9]+)?", s)
        if a.group(0) == s:
            return True
        else:
            return False
group([group1, …])方法用于获得一个或多个分组匹配的字符串,当要获得整个匹配的子串时,可直接使用 group()group(0)

54.字符流中第一个不重复的字符

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如,当从字符流中只读出前两个字符"go"时,第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时,第一个只出现一次的字符是"l"。

输出描述:

如果当前字符流没有存在出现一次的字符,返回#字符。

思路:

由于字符属性,可以用一个长为256的数组巧妙地存储每个字符出现的位置。字符本身的ascii码当作数组index。初始化数组每个元素都为-1。

  • 假设这个字符是第一次出现,那么把-1替换成这个字符出现的index;
  • 假设这个字符不是第一次出现,即这个位置的值>0,那么把这个位置的值变成-2;

最后在该数组中找到>0的最小值,这个位置所代表的字符就是结果。

class Solution:
    # 返回对应char
    def __init__(self):
        self.list = [-1]*256 
        self.index = 0
    def FirstAppearingOnce(self):
        tmp_min = 1000
        index = -1
        for i in range(len(self.list)):
            if self.list[i] >= 0 and tmp_min > self.list[i]:
                index = i
                tmp_min = self.list[i]
        if index >= 0:
            return chr(index)
        else:
            return '#'
        
    def Insert(self, char):
        if self.list[ord(char)] == -1:
            self.list[ord(char)] = self.index
        elif self.list[ord(char)] == -2:
            pass
        else:
            self.list[ord(char)] = -2
        self.index += 1

55.链表中环的入口结点

给一个链表,若其中包含环,请找出该链表的环的入口结点,否则,输出null。

思路:

我的憨憨思路vs大佬们的巧妙思路,完败

我的思路:遍历链表所有node,把出现过的node都存储到一个list中,每次遍历到下一个node的时候,判断一下该node是否存在于list中,是的话说明是入口node,返回它。

如下图所示,依次把1,2,3,4,5,6加入list中,当再加入3时,发现3已经在list中,返回3作为入口节点。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第18张图片
3是入口节点
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        nodes = []
        h = pHead
        while h.next:
            if h in nodes:
                return h
            nodes.append(h)
            h = h.next
        return None

敲黑板来了!讲一下大佬的思路,这题也是比较经典的快慢指针问题。之前的快慢指针可参考链表倒数第k个节点,日更四中的问题14~

嘿我头发呢:剑指offer系列python实现 日更(四)​zhuanlan.zhihu.com
python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第19张图片

在本题中,设置快慢两个指针,初始都指向head。快指针每次走2步,慢指针每次走1步

有两个结论:

  1. 假如存在环,那么它们一定会相遇在环中某一节点;
  2. 用两个指针分别从链表头和相遇点出发,每次走1步,最后一定相遇与环入口。

结论1比较好想,假设存在环的话,两个指针进入环,就是一个追逐过程。快指针总会追上慢指针~

证明结论2:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第20张图片

假设链表头到环入口节点数为a,环入口到快慢指针相遇点节点数为b,相遇点到环入口节点数为c。

当快慢指针再相遇点相遇时,

快指针走过的路程=a + (b + c)* k + b,

k>=1, b+c是环的长度,k是圈数,必须超过0圈,不然和慢指针一样。

慢指针走过的路程=a +(b + c)*m + b, m>=0

由于快指针比慢指针快1倍,所以路程是慢指针的1倍:

a + (b + c)* k + b = 2(a +(b + c)*m + b)

化简

a=(k-2m-1)(b+c)+c ,这意味着链表头到环入口的距离 = 整数圈数 + 相遇点到环入口的距离。这也意味着,如果两个指针一个从链表头开始,一个从快慢指针相遇点开始,那么他们最后一定会在环入口相遇。

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, phead):
        fast, slow = phead, phead
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
            if slow==fast:
                slow2=phead
                while slow!=slow2:
                    slow=slow.next
                    slow2=slow2.next
                return slow

56.删除链表中重复的结点

在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针。 例如,链表1->2->3->3->4->4->5 处理后为 1->2->5

思路:

递归了!

复习一下:假设子问题我们都已经完美解决,那么最后一步是什么呢?

首先要记住这个链表是排序的链表~

假设前面都已经是不重复的结点,最后一步我们就是需要判断当前结点和后面的结点是否有重复若有重复则全部跳过,若不重复则保留当前节点

这里需要记得考虑只有0或者1个结点的情况~

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplication(self, phead):
        if not phead: return phead
        if not phead.next: return phead
        if phead.val != phead.next.val:
            phead.next = self.deleteDuplication(phead.next)
            return phead
        else:
            p = phead.next
            while p and p.val == phead.val:
                p = p.next
            return self.deleteDuplication(p)

57.二叉树的下一个结点

给定一个二叉树和其中的一个结点,请找出中序遍历顺序的下一个结点并且返回。注意,树中的结点不仅包含左右子结点,同时包含指向父结点的指针。

思路:

在题目中,node.next是指向父结点的指针。这里需要回顾一下中序遍历顺序:左根右。

这时候有几种情况要考虑:

  1. 假设结点有右子节点:那么就很简单,中序遍历顺序的下一个结点就是右子节点的最左子节点。如下图中的B,有右子结点E,那么返回E的最左子节点G即可。
  2. 假设结点没有右子节点,说明需要向上查找,情况又分几种
  • 判断是否有父节点,且是父节点的左子节点,返回父节点,比如下图的G,没有右子节点,但是是E的左儿子,这个时候返回E;
  • 判断是否有父节点,但不是父节点的左子节点继续向上找。比如下图的E,它没有右子节点,也不是B的左子节点,这说明B已经被返回了,这个时候需要查找B的父亲,并且判断B是不是它父亲的左子节点,重复上述过程。对于E来说,返回A。
  • 如果找到根结点还是找不到,返回null,比如F。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第21张图片
# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def GetNext(self, pNode):
        if not pNode:
            return pNode
        if pNode.right:
            left = pNode.right
            while left.left:
                   left = left.left
            return left
        while pNode.next:
            father = pNode.next
            if father.left == pNode:
                return father
            pNode = father

58.对称的二叉树

请实现一个函数,用来判断一颗二叉树是不是对称的。注意,如果一个二叉树同此二叉树的镜像是同样的,定义其为对称的。

思路:

我们先看看对称的二叉树长什么样子:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第22张图片

题目中给了提示:如果一个二叉树同此二叉树的镜像是同样的,定义其为对称的,复习一下二叉树镜像~参考日更(五)中的问题18:

嘿我头发呢:剑指offer系列python实现 日更(五)​zhuanlan.zhihu.com
python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第23张图片

二叉树镜像的主要思路是:当前的结点左右结点交换,然后再对当前结点的左右结点递归做镜像~ 最后返回根结点即可。

本题中,我们需要的是比较左右子树是否是镜像的,转换一下思路:当前的结点左右结点判断是否val一样,然后再对当前结点的左右结点递归做镜像判断~

  • 假设当前两个结点是空,可返回True;
  • 假设当前两个结点有一个不为空,返回False;
  • 判断一下两个节点值是否一致?
    • 若不一致返回False;
    • 若一致则递归地对node1.left 与node2.right node2.left 与node1.right 继续判断是否是对称的。如下图中,对两个2的左右子树,颜色相同的一起判断。

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第24张图片
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def compare(self, node1, node2):
        if not node1 and not node2:
            return True
        if not node1 or not node2:
            return False
        if node1.val == node2.val:
            return self.compare(node1.left, node2.right) and self.compare(node1.right, node2.left)
        else:
            return False
    def isSymmetrical(self, pRoot):
        if not pRoot:
            return True
        return self.compare(pRoot.left, pRoot.right)

59.按之字形顺序打印二叉树

请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推。

思路:

一个之字形输出栗子:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第25张图片
输出ACBDEF

当看到按照行打印时,第一想法就是广度优先搜索。让我们先回顾一下之前的从上往下打印二叉树,参考日更(六)的问题22:

嘿我头发呢:剑指offer系列python实现 日更(六)​zhuanlan.zhihu.com
python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第26张图片

问题22中是用一个list来模拟队列先入先出:把每一层的结点都放到nodes当中,并且当遍历到当前结点时,将结点值存到res中。如果当前结点有左or右子结点,就将左or右子结点放到nodes队列尾部。

那么本题其实只需要变换一下下,在偶数层逆序输出即可。

用一个ct代表当前层数,nodes存储每层结点,tmp暂存每层的结点,child存储当前层结点的孩子结点。若当前层数为偶数层,把tmp反转,放入res结果中。

一个和问题22的小区别在于,问题22输出形式为[1,2,3,4,5,...], 本题输出形式为:[[1], [2,3], [4,5,6,7]....],把每层结点又套进了一个list中。

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Print(self, proot):
        if not proot:
            return []
        ct = 0
        nodes, res = [proot],[]
        while nodes:
            ct += 1
            childs = []
            tmp = []
            for i in nodes:
                tmp.append(i.val)
                if i.left:
                    childs.append(i.left)
                if i.right:
                    childs.append(i.right)
            if ct % 2 == 0:
                tmp = tmp[::-1]
            res.append(tmp)
            nodes = childs
        return res

60.把二叉树打印成多行

从上到下按层打印二叉树,同一层结点从左至右输出。每一层输出一行。

思路:

我仿佛时空穿梭,这题果然要和上一题一起看~ 它们的区别在于:本题不需要偶数层反向输出。

既然如此,我们把参考上题的实现,把偶数层反向输出部分删除:用nodes存储每层结点,tmp暂存每层的结点,child存储当前层结点的孩子结点。

当nodes不为空时,每次把nodes层数遍历一遍,把暂存的每层结点加入结果中,并且让nodes等于child,即当前层结点的孩子结点

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, proot):
        if not proot:
            return []
        nodes, res = [proot],[]
        while nodes:
            childs = []
            tmp = []
            for i in nodes:
                tmp.append(i.val)
                if i.left:
                    childs.append(i.left)
                if i.right:
                    childs.append(i.right)
            res.append(tmp)
            nodes = childs
        return res

61.序列化二叉树

请实现两个函数,分别用来序列化和反序列化二叉树

二叉树的序列化是指:把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串,从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改,序列化的结果是一个字符串,序列化时通过 某种符号表示空节点(#),以 ! 表示一个结点值的结束(value!)。 二叉树的反序列化是指:根据某种遍历顺序得到的序列化字符串结果str,重构二叉树。

例如,我们可以把一个只有根节点为1的二叉树序列化为"1,",然后通过自己的函数来解析回这个二叉树。

思路:

先皮一下,送命答法:

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Serialize(self, root):
        return root
    def Deserialize(self, s):
        return s

这题还是比较简单的,假设有一颗这样的树:

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第27张图片

可以选择某种遍历方式序列化,这里笔者选择先序遍历:根左右。

  • 遍历后得到的序列化结果应为:A,B,#,D,#,#,C,E,#,#,F,#,#
  • 根据这个序列化结果,反序列化还原成二叉树。

序列化采用的先序遍历还是我们的老朋友,递归~ 这里需要注意一点,这里用一个字符串存储结果,遇到空值返回'#,',当不为空,用逗号','分隔开每个结点。注意!这里应该返回'#,'而不是'#',在这里卡了一会,原因是入股出现上图中的B结点情况,返回#之后应该继续遍历,所以还需要有逗号分隔~

反序列化需要一点小技巧:我们用一个ct存储结点在序列化结果中的index

l是以逗号分隔符分隔了s后的数组,该数组仅由二叉树结点和#组成。这个时候依次遍历这个数组里每个元素,实例化每个结点即可!

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def __init__(self):
        self.ct = -1
    def Serialize(self, root):
        if not root:
            return '#,'
        return str(root.val) + ',' + self.Serialize(root.left) + self.Serialize(root.right)
    def Deserialize(self, s):
        self.ct += 1
        l = s.split(',')
        if self.ct >= len(l) or l[self.ct] == '#':
            return None
        root = TreeNode(int(l[self.ct]))
        root.left = self.Deserialize(s)
        root.right = self.Deserialize(s)
        return root

62.二叉搜索树的第k个结点

给定一棵二叉搜索树,请找出其中的第k小的结点。例如, (5,3,7,2,4,6,8) 中,按结点数值大小顺序第三小结点的值为4。

思路:

二叉搜索树的中序遍历结果就是树结点值按照顺序从小到大排序~ 所以这题我们得到树的中序遍历结果,再取出第k个值即可。

递归的方法求中序遍历:左根右,依次把中序遍历node加入到ino这个list中。

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回对应节点TreeNode
    def __init__(self):
        self.ino = []
    def inorder(self, root):
        if not root:
            return None
        self.inorder(root.left)
        self.ino.append(root)
        self.inorder(root.right)
    
    def KthNode(self, proot, k):
        self.inorder(proot)
        if not proot or k <= 0 or len(self.ino) < k:
            return None
        return self.ino[k-1]

63.数据流中的中位数

如何得到一个数据流中的中位数?如果从数据流中读出奇数个数值,那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值,那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流,使用GetMedian()方法获取当前读取数据的中位数。

思路:

其实这题有一个比较简单的做法:

  • 每次插入元素的时候对所有数据排序;
  • 每次取出的时候判断一下数组内元素个数是奇数还是偶数,再返回对应数值。

但是这个方法有一个缺点,就是每次插入就要进行排序,python内置排序算法是timsort,它在输入已经有序的时候性能较好,时间复杂度是O(n)

注意,网站上的GetMedian函数需要手动增加一个参数x,不然会报错。。

class Solution:
    def __init__(self):
        self.data = []
    def Insert(self, num):
        # write code here
        self.data.append(num)
        self.data.sort()
        return self.data
    def GetMedian(self,x ):
        l = len(self.data)
        if l % 2 == 0:
            return (self.data[l/2] + self.data[l/2 - 1])/2.0
        else:
            return self.data[l/2]

另一种方法,这里贴上大佬的思路,借鉴一下:

利用两个堆,一个最大堆一个最小堆,最大堆存数据流中较小的数,最小堆存数据流中较大的数。
保证:小顶堆中的元素都大于等于大顶堆中的元素,所以每次插值,并不是直接塞进去,而是从另一个堆中poll出一个最大(最小)的塞值
当数目为偶数的时候,将这个值插入大顶堆中,再将大顶堆中根节点(即最大值)插入到小顶堆中;
当数目为奇数的时候,将这个值插入小顶堆中,再讲小顶堆中根节点(即最小值)插入到大顶堆中;
取中位数的时候,如果当前个数为偶数,显然是取小顶堆和大顶堆根结点的平均值;如果当前个数为奇数,显然是取小顶堆的根节点

由于堆调整的复杂度为O(logn),所以相比于上一个思路,利用堆的数据结构在时间复杂度上会更优~

64.滑动窗口的最大值

给定一个数组和滑动窗口的大小,找出所有滑动窗口里数值的最大值。例如,如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3,那么一共存在6个滑动窗口,他们的最大值分别为{4,4,6,6,6,5}; 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个: {[2,3,4],2,6,2,5,1}, {2,[3,4,2],6,2,5,1}, {2,3,[4,2,6],2,5,1}, {2,3,4,[2,6,2],5,1}, {2,3,4,2,[6,2,5],1}, {2,3,4,2,6,[2,5,1]}。

思路:

这题比较简单,利用python的切片,让窗口逐渐向后滑动,每次返回切片范围内最大的元素即可。需要注意一下窗口值为0的处理~

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第28张图片
黄色代表滑动窗口,依次向右滑动
class Solution:
    def maxInWindows(self, num, size):
        res = []
        if size <=0:
            return []
        for i in range(len(num)-size +1):
            res.append(max(num[i: i+size]))
        return res

65.矩阵中的路径

请设计一个函数,用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始,每一步可以在矩阵中向左,向右,向上,向下移动一个格子。如果一条路径经过了矩阵中的某一个格子,则该路径不能再进入该格子。 例如

python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下)_第29张图片

矩阵中包含一条字符串"bcced"的路径,但是矩阵中不包含"abcb"路径,因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后,路径不能再次进入该格子。

思路:

主要思路还是深度优先搜索回溯法的经典题型。回溯法也是深度优先搜索的一种~

回溯法是将路径存入到一个中,递归地寻找周围有没有符合条件的格子,如果一旦有,就继续压入栈中(不管周围是不是还有其它符合条件的格子)。重复过程直到遇到周围都找不到的情况,这个时候pop当前这个格子,回退到上一个格子,在上一个格子周围继续找是否有满足条件的格子。重复以上的过程直到递归停止~

这题由于要持续寻找附近的格子,很容易想到利用递归实现~ 递归的中止条件是什么呢?

1. 越界,超过给出的矩阵边界;
2. 周围格子没有匹配的字母;
3. 周围格子都已经走过。

在以上3种情况都说明此路不通,可以换下条路。

已经匹配到字符串最后一个字符,且存在这样的路径。

以上情况返回True,说明找到了该路径。

注意,由于走过了的格子不能再走,所以需要一个和原矩阵同维度的matrix,存储是否走过对应格子。每次回溯的时候,该矩阵对应状态也需要变化~

另一个吐槽,牛客给出的数组是一维的!!还寻思为啥要给出rows和cols,人晕了

def isHasPath(self, matrix,rows,cols,curRow,curCol,path,index,visited):
        if index == len(path):
            return True
        hasPath = False
        if curRow >= 0 and curRow < rows and curCol >= 0 and curCol < cols and matrix[curRow*cols + curCol] == path[index] and not visited[curRow*cols + curCol]:
            index+=1
            visited[curRow*cols+curCol] = True
            l = self.isHasPath(matrix,rows,cols,curRow,curCol-1,path,index,visited) 
            u = self.isHasPath(matrix,rows,cols,curRow-1,curCol,path,index,visited) 
            r = self.isHasPath(matrix,rows,cols,curRow,curCol+1,path,index,visited) 
            d = self.isHasPath(matrix,rows,cols,curRow+1,curCol,path,index,visited)
            hasPath = l or u or r or d
            if not hasPath:
                index -= 1
                visited[curRow*cols+curCol] = False
        return hasPath
    def hasPath(self, matrix, rows, cols, path):
        # write code here
        if path is None or path == '' or rows <= 0 or cols <= 0:
            return False
        visited = [False for i in range(rows*cols)]
        index = 0
        for i in range(rows):
            for j in range(cols):
                if self.isHasPath(matrix,rows,cols,i,j,path,index,visited):
                    return True
        return False

66.机器人的运动范围

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动,每一次只能向左,右,上,下四个方向移动一格,但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如,当k为18时,机器人能够进入方格(35,37),因为3+5+3+7 = 18。但是,它不能进入方格(35,38),因为3+5+3+8 = 19。请问该机器人能够达到多少个格子?

思路:

这题和上题思路有点像!

用一个matrix存储m行n列矩阵,初始化所有都为1,表示机器人是否可以走到这个格子。

中止条件就是:越界,或行坐标和列坐标的数位之和大于k

用ct存储可以走的格子个数,从(0,0)开始,如果满足条件可以继续,ct +=1。然后再从当前位置的上下左右方向继续寻找。最后返回ct即可。

class Solution:
    def __init__(self ):
        self.ct = 0
        
    def movingCount(self, threshold, rows, cols):
        
        visit = [[1 for i in range(cols)] for j in range(rows)]
        self.move(visit, 0, 0, threshold)
        return self.ct
    
    def move(self, visit, i, j, threshold):
        if i < 0 or j < 0 or i >= len(visit) or j >= len(visit[0]):
            return
        sum_i = sum(list(map(int, list(str(i)))))
        sum_j = sum(list(map(int, list(str(j)))))
            
        if sum_i + sum_j > threshold or visit[i][j] != 1:
            return
        self.ct += 1
        visit[i][j] = 0
        self.move(visit,i-1, j, threshold)
        self.move(visit,i+1, j, threshold)
        self.move(visit,i, j-1, threshold)
        self.move(visit,i, j+1, threshold)

67.剪绳子

给你一根长度为n的绳子,请把绳子剪成整数长的m段(m、n都是整数,n>1并且m>1),每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]xk[1]x...xk[m]可能的最大乘积是多少?例如,当绳子的长度是8时,我们把它剪成长度分别为2、3、3的三段,此时得到的最大乘积是18。输入一个数n,意义见题面。(2 <= n <= 60)

示例1

输入:8
输出:18

思路:

这题也是属于经典的动态规划问题~

不管我们最终得到的绳子有几段,一定存在一个划分点i,把绳子切分成两段,而两段分别可以求相应的长度乘积最大值(最小子问题)。

而对于该绳子来说,乘积最大值就是这两段分别的最大值之积。

假设函数f(x),代表长度为x的绳子的最大乘积。那么对于切分点i来说:

f(x) = f(i) * f(x - i)

由于对称性的存在,即切在长度为 i 和长度为 x-i 处得到结果是一样的,所以j的切分的范围应该在1~n/2之间。

  • 当n <= 3的时候,由于必须要切分,所以这个时候可以归纳返回。
  • 当n >= 4的时候,这个时候如果遇到长度为3,就可以不用切分,直接乘以3。

用dp数组存放长度为x的绳子的最大乘积,且此时number大于4。易知:

dp[0] = 0 
dp[1] = 1 
dp[2] = 2  # 当number大于4,长度为2不用切分
dp[3] = 3  # 当number大于4,长度为3不用切分

代码中需要提前返回number 等于2和3的情况,再对dp进行赋值。

class Solution:
    def cutRope(self, number):
        if number == 2:
            return 1
        if number == 3:
            return 2
        dp = [-1]*61
        dp[1] = 1
        dp[2] = 2
        dp[3] = 3
        for i in range(4, (number+1)):
            tmpmax = 0
            for j in range(1, i//2 + 1):
                tmpmax = max(tmpmax, dp[j]*dp[i-j])
            dp[i] = tmpmax
        return dp[number]

另一种解决方法:

让我们先来归纳一下每个长度的绳子最大乘积情况:

4: 2*2
5: 2*3
6: 3*3
7: 2*2*3 /  4*3
8: 2*3*3
9: 3*3*3
10: 2*2*3*3 /  4*3*3: 
11: 2*3*3*3
12: 3*3*3*3
13: 2*2*3*3*3 /  4*3*3*3

发现没有!除了2就是3!

那么有同学可能疑惑,为什么没有比3大的数字

4 = 2*2
5 < 2*3
6 < 3*3
7 < 2*3*3

那么2和3的数量又是什么关系呢?

6 = 2+2+2 = 3+3

但是:

2*2*2 < 3*3

所以2的数量一定小于3的数量,这题就变成了找尽可能多的3~

  • 假设n恰好整除3,那么结果就是3的n//3次方(n//3代表n除以3的整数部分);
  • 假设n除以3余1,那么可以拿出1个3,和最后的余数1相加变成4,最后结果是:3**(number//3-1)*4 ;
  • 假设n除以3余2,那么结果就是:3**(number//3)*(number%3)
class Solution:
    def cutRope(self, number):
        res = 1
        if number <= 1:
            return 0
        elif number <= 2:
            return 1
        elif number <= 3:
            return 2
        elif number > 3:
            if number % 3 == 0:
                res = 3**(number//3)
            elif number%3 == 1:
                res = 3**(number//3-1)*4
            else:
                res = 3**(number//3)*(number%3)
        return res

你可能感兴趣的:(python中输入几个数将其以ascii码大小排序_《剑指offer》python实现 合集(下))