剑指offer系列之数组及字符串(p48-53)

最新推荐文章于 2023-03-04 17:46:05 发布

Cheng Qian

最新推荐文章于 2023-03-04 17:46:05 发布

阅读量103

点赞数

分类专栏：剑指offer coding python

本文链接：https://blog.csdn.net/xiayangmian4130/article/details/89057737

版权

coding 同时被 3 个专栏收录

35 篇文章 0 订阅

订阅专栏

剑指offer

34 篇文章 0 订阅

订阅专栏

python

15 篇文章 0 订阅

订阅专栏

48. 把字符串转换成整数

题目描述

知识点：字符串
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0。

思路

这道题使用python反而有点烦琐了，关键点在于'0'->0的转换，在C/C++中可以使用'0'-'0'来实现，但是在python中不可以，因此这里使用了list的index来实现这种转换，这也导致了空间复杂度增大为 $O (n)$ ，时间复杂度也为 $O (n)$ .

# -*- coding:utf-8 -*-
class Solution:
    def StrToInt(self, s):
        # write code here
        length = len(s)
        if length < 1:
            return 0
        res = 0
        numlist = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
        for i in range(length):
            if i == 0:
                if '0' <= s[i] <= '9':
                    res = numlist.index(s[i])
                    continue
                if s[i] != '+' and s[i] != '-':
                    return 0
                continue
            if s[i] in numlist:
                res = res * 10 + numlist.index(s[i])
            else:
                return 0
        if s[0] == '+' or '0' <=s[0] <= '9':
            return res
        elif s[0] == '-':
            return -res

49. 数组中重复的数字

题目描述

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

思路

思路一：Hash法

该方法需要辅助数组，因此时间复杂度和空间复杂度都为 $O (n)$ .

# -*- coding:utf-8 -*-
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        length = len(numbers)
        if length <= 1:
            return False
        tmp = [0] * length
        for nb in numbers:
            tmp[nb] += 1
            if tmp[nb] > 1:
                duplication[0] = nb
                return True
        return False

思路二

思路二把数组视为当前位置上的元素等于它的索引的数组，即 $a [i] = i$ .
step 1: 从0开始遍历数组，若当前元素等于它的索引，则继续向后遍历；若不相等则进行步骤2.
step 2：判断当前元素的位置处 $(第 a [i] 个)$ 的元素 $(a [a [i]])$ 是否等于它的索引，若相等，则成功找到重复数字，因为 $a [a [i]] = a [i]$ ，即第 $i$ 个位置和第 $a [i]$ 个位置处元素值相同；若不相等，则交换第 $i$ 个位置和第 $a [i]$ 个位置处的元素，交换后必然有 $a [a [i]] = a [i]$ ，但是第 $i$ 个位置不一定满足 $a [i] = i$ .重复进行步骤2.
该方法虽然有两层循环，但是时间复杂度为 $O (n)$ ,因为while循环中的交换次数加起来一定是小于等于 $n$ 次的。

# -*- coding:utf-8 -*-
class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        length = len(numbers)
        if length <= 1:
            return False
        # 判断数组是否合法
        for num in numbers:
            if num < 0 or num >= length:
                return False
        # 
        for i, num in enumerate(numbers):
            while numbers[i] != i:
                # 不是同一个位置上的两个数相等
                if numbers[numbers[i]] == numbers[i]:
                    duplication[0] = numbers[i]
                    return True
                else:
                    tmp = numbers[numbers[i]]
                    numbers[numbers[i]] = numbers[i]
                    numbers[i] = tmp
        return False

50. 构建乘积数组

题目描述

本题知识点：数组
给定一个数组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]。不能使用除法。

思路

先求下三角，再求上三角。时间复杂度为 $O (n)$ 。
在这里插入图片描述

# -*- coding:utf-8 -*-
class Solution:
    def multiply(self, A):
        # write code here
        length = len(A)
        if length <= 1:
            return A
        B = [1] * length
        # 计算下三角
        for i in range(1, length):
            B[i] = B[i - 1] * A[i -1]
        # 计算上三角
        tmp = 1
        for i in range(length-2, -1, -1):
            tmp *= A[i + 1]
            B[i] *= tmp
        return B

49. 正则表达式匹配

题目描述

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

思路

该题可以分为四种情况：

s、pattern均为空，直接返回True；
s不为空、pattern为空，直接返回False；
s为空、pattern不为空，需要进行进一步判断；
s、pattern都不为空，需要进一步判断。

以下各种方法的区别点就主要在于第四步的进一步判断。

思路一：

这种方法的主要关键点就在于对于每种情况，先判断pattern的第二个字符是否是*，然后再判断s和pattern的第一位是否匹配。

# -*- coding:utf-8 -*-
class Solution:
    # s, pattern都是字符串
    def match(self, s, pattern):
        # write code here
        # s和pattern都为空
        if len(s) == 0 and len(pattern) == 0:
            return True
        # s不为空，pattern为空
        elif len(s) > 0 and len(pattern) == 0:
            return False
        # s为空，patter不为空
        elif len(s) == 0 and len(pattern) > 0:
            # 第二个如果是*前面两个就可以当作不存在
            if len(pattern) > 1 and pattern[1] == '*':
                return self.match(s, pattern[2:])
            # 只有一个*也是直接满足条件
            elif len(pattern) == 1 and pattern[0] == '*':
                return True
            else:
                return False
        # s, pattern都不为空
        else:
            # 判断pattern第二个字符是否是*
            if len(pattern) > 1 and pattern[1] == '*':
                # 判断s、pattern第一个字符是否匹配
                if s[0] != pattern[0] and pattern[0] != '.':
                    return self.match(s, pattern[2:])
                else:
                    # s、pattern第一个字符匹配有三种情况
                    # 仅将pattern后移两位，可以当pattern前两位不存在
                    # 仅将s后移1位,即将pattern前两位利用多次
                    # 将s后移1位、将pattern后移两位。相当于pattern前两位仅仅可以匹配第一位
                    return self.match(s, pattern[2:]) or self.match(s[1:], pattern) or self.match(s[1:], pattern[2:])
            # pattern第二个字符不是*
            else:     
                if s[0] != pattern[0] and pattern[0] != '.':
                    return False
                else:
                    return self.match(s[1:], pattern[1:])

思路二

先判断是否匹配，再判断pattern的第二个字符是否是*。

# -*- coding:utf-8 -*-
class Solution:
    # s, pattern都是字符串
    def match(self, s, pattern):
        # write code here
        if not s and not pattern:
            return True
        elif s and not pattern:
            return False
        elif not s and pattern:
            if len(pattern) > 1 and pattern[1] == '*':
                return self.match(s, pattern[2:])
            else:
                return False
        else:
            # 首位能否匹配
            if s[0] == pattern[0] or pattern[0] == '.':
                if len(pattern) > 1 and pattern[1] == '*':
                    return self.match(s, pattern[2:]) or self.match(s[1:], pattern) or self.match(s[1:], pattern[2:])
                else:
                    return self.match(s[1:], pattern[1:])
            else:
                if len(pattern) > 1 and pattern[1] == '*':
                    return self.match(s, pattern[2:])
                else:
                    return False

Tips:
做题目时一时没想明白为什么满足了第一位匹配并且pattern第二位为*还要做self.match(s, pattern[2:])，其实这是基于*前的字符可以出现0次考虑的。如s='bbbba',pattern='.*a*a'。
另外需补充动态规划算法，详见牛客网评论。

50. 表示数值的字符串

题目描述

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

思路

分别考虑符号位 $(+ 、 -)$ 、小数点 $(.)$ 、E $(/ e)$ 、数字位 $(0 - 9)$ 的情况。

对于符号位只能出现在第一位或者e后面一位；
对于小数点，只能出现在e之前且至多出现一次；
对于E，至多出现一次且其后必须跟着整数，也就是不能出现在最后一位；
对于数字位，必须在0-9之间。

该方法时间复杂度位 $O (n)$ 。

# -*- coding:utf-8 -*-
class Solution:
    # s字符串
    def isNumeric(self, s):
        # write code here
        if len(s) == 0:
            return False
        has_e, has_point, has_sign = False, False, False
        for i in range(len(s)):
            # 考虑e的情况
            if s[i] == 'e' or s[i] == 'E':
                if has_e:
                    return False
                # e不能出现在最后一位，即后面必须跟着数字
                else:
                    has_e = True
                    if i == len(s) - 1:
                        return False
            # 考虑符号
            elif s[i] == '+' or s[i] == '-':
                if has_sign:
                    # e已经出现过了，但是符号位没有紧跟着e
                    if has_sign and s[i-1] != 'e' and s[i-1] != 'E':
                        return False
                else:
                    has_sign = True
                    # 符号位没出现过但是出现的位置不是第一位也不是e之后
                    if i > 0 and s[i-1] != 'e' and s[i-1] != 'E':
                        return False
            # 考虑小数点
            elif s[i] == '.':
                # 至多出现一次小数点并且小数点不能存在e之后
                if has_point or has_e:
                    return False
                else:
                    has_point = True
            # 考虑数字
            elif s[i] > '9' or s[i] < '0':
                return False
        return True

52. 字符流中第一个只出现一次的字符

题目描述

知识点：字符串
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。

思路

一开始拿到题目给定两个函数觉得题意没说清楚。函数FirstAppearingOnce是用来查找字符串中第一个只出现一次的字符，函数Insert是用来往字符流中插入新的字符，其实就是相当于再读入一个字符。执行逻辑是先执行插入操作，再查找第一个只出现一次的字符。

思路一：HashMap

思路一非常简单，主要是利用了python的dict使得实现更加容易，该方法的时间复杂度为 $O (n)$ ，空间复杂度也为 $O (n)$ .

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.s = ''
        self.count_dict = {}

    # 返回对应char
    def FirstAppearingOnce(self):
        # write code here
        for e in self.s:
            if self.count_dict[e] == 1:
                return e
        return '#'
    
    def Insert(self, char):
        # write code here
        self.s += char
        self.count_dict[char] = self.count_dict.get(char, 0) + 1

思路二

第二种方法主要是利用了一个队列来存储当前只出现一次的字符。
插入函数的逻辑为若当前字符只出现一次，则直接插入，否则什么也不做。
对于查找函数来说，首先判断队首元素是否只出现一次，如果是则直接返回队首元素；否则直接弹出第一个元素（弹出的元素对于之后的查找也是没影响的，因为他的出现次数大于1了），继续执行对队首元素的判断。
该方法的空间复杂度为 $O (n)$ ，时间复杂度为 $O (1)$ 。在查找函数中虽然有一个while循环，但是这个while循环至多只能执行常数次(所有字符的可能个数)，因此时间是常数级的。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.queue = []
        self.count_dict = {}

    # 返回对应char
    def FirstAppearingOnce(self):
        # write code here
        while len(self.queue) > 0 and self.count_dict[self.queue[0]] > 1:
            self.queue.pop(0)
        if len(self.queue) == 0:
            return '#'
        else:
            return self.queue[0]

    def Insert(self, char):
        # write code here
        self.count_dict[char] = self.count_dict.get(char, 0) + 1
        if self.count_dict[char] == 1:
            self.queue.append(char)

Cheng Qian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer系列之数组及字符串(p48-53)

48. 把字符串转换成整数题目描述知识点：字符串将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。数值为0或者字符串不是一个合法的数值则返回0。思路这道题使用python反而有点烦琐了，关键点在于'0'->0的转换，在C/C++中可以使用'0'-'0'来实现，但是在p...
复制链接

扫一扫

专栏目录