剑指offer整理(附python代码)——字符串

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/JinFeiXiBi123456789/article/details/81042175

1.替换空格

问题描述

请实现一个函数,将一个字符串中的空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

考察点:字符串匹配

思路1 创建新的字符串存最终结果(以下采用2)

  1. 1st顺序遍历字符串,确定除空格外字符串长度
  2. 2nd顺序遍历字符串,顺序存储,碰到字符串就直接存储,空格就存‘20%’

思路2 在原数组上进行扩充

  1. 顺序遍历字符串,确定空格个数,确定新字符串长度
  2. 逆序遍历字符串,逆序存储,碰到字符串就直接存储,空格就存‘20%’
class Solution11:
    def replaceSpace(self, s):
        # write code here
        r=""
        s=s.split(" ")
        n=len(s)
        #取除最后一个字符外的所有字符
        for i in s[:n-1]:
            print i
            r=r+i+"%20"
        #将最后一个字符加入修改后的字符串
        r+=s[n-1]
        return r

if __name__ == '__main__':
    s = Solution11()
    print s.replaceSpace("123 hello 234")
123
hello
123%20hello%20234

2.二进制中1的个数

问题描述

输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。

考察点:位运算

  • 有符号数,正(首位0)、负(首位1)
  • 二进制中的5中运算:与(&)、或(|)、异或(^,相异为1)、左移(<<)、右移(>>)
  • 左移(m<<n):将m左移n位,左侧的舍去,右侧补0。
  • 右移(m>>n):将m左移n位,右侧舍去,左侧补0/符号位(若为有符号数)。
  • 二进制补码:正数(不变)、负数(除符号位外,其余按位取反,然后再加1)

思路

  • 可能陷入死循环的解法:从n的2进制形式的最右边开始判断是不是1。(跟1做“与&”) 但是:若输入时负数会陷入死循环,因为负数右移时,在最高位补得是1,那么会有无数个1了。
  • 正解思想:将待比较的数‘1’左移(其实后来就不是1了),和n的每位进行位与,来判断1的个数。 可以避免原数右移,可能增加1的情况。
  • 最优解思想:把一个整数减去1,再和原整数做“与”,会把该整数最右边一个1变为0。那么一个整数的二进制表示中有多少个1,就可以进行多少次这样的操作。
    举个例子:一个二进制数1100,从右边数起第三位是处于最右边的一个1。减去1后,第三位变成0,它后面的两位0变成了1,而前面的1保持不变,因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。 这个时候如果我们再把原来的整数和减去1之后的结果做与运算,从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说,把一个整数减去1,再和原整数做与运算,会把该整数最右边一个1变成0. 那么一个整数的二进制有多少个1,就可以进行多少次这样的操作。
# 正解
# private static int NumberOf1_low(int n) {
#     int count = 0;
#     int flag = 1;
#     while (flag != 0) {
#         if ((n & flag) != 0) {
#             count++;
#         }
#         flag = flag << 1;
#     }
#      return count;
#     }
class Solution2:
    # 最优解
    def NumberOf1(self, n):
        # write code here
        count = 0
        if n<0:
            # 把负号去掉,0xFFFFFFFF代表一个16进制数,转为2进制为:32个1.
            n=n&0xFFFFFFFF
        while n:
            n = n&(n-1)
            count+= 1
        return count

if __name__ == '__main__':
    s = Solution2()
    print s.NumberOf1(-54)
28

3.字符串的排列

问题描述

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

考察点:字符串的全排列

思路1

  1. 将字符串分为两部分:首字符+其后的所有字符;求其后字符的全排列
  2. 拿第一个字符与其后的字符逐个交换
class Solution:
    def Permutation(self,ss):
        if not ss:
            return []
        if len(ss)==1:
            # 返回列表形式的字符串
            return list(ss)
        allList = []
        charList = list(ss)
        charList.sort()  #按字典顺序进行排列,不去重
        for i in range(len(charList)):
            # 限制i>0 : 防止charList[i-1]下标越界
            if i>0 and charList[i]==charList[i-1]:
                continue # 忽略重复的字符
            #Permutation():乱序,接受array类型及int类型的输入。
            #shuffle():乱序,只接受array类型输入。
            temp = self.Permutation(''.join(charList[:i])+''.join(charList[i+1:]))
            for j in temp:
                allList.append(charList[i]+j)
        return allList
s = Solution()
s.Permutation('abc')
            
['abc', 'acb', 'bac', 'bca', 'cab', 'cba']

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

问题描述

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

考察点:字符串的统计

思路1:O(n)

  1. 用字典统计每个字符出现的次数(自己统计)
  2. 按顺序,以str中字符为key,判断字典中统计的出现次数是否为1,是则输出下标。

思路2: 更快

  1. 用‘内置方法’统计字符串中字符出现的次数count()
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        sdict = {}
        for i in range(len(s)):
            if sdict.has_key(s[i]):
                sdict[s[i]] += 1
            else:
                sdict[s[i]] = 1
        for i in range(len(s)):
            if (sdict[s[i]]==1):
                return i 
        return -1
s = Solution()
s.FirstNotRepeatingChar('')
-1
class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        for k,i in enumerate(s):
            # 内置函数,直接统计出现次数
            if s.count(i)==1:
                return k
        return -1
s = Solution()
s.FirstNotRepeatingChar('google')
4

5.左旋转字符串

问题描述

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

考察点:知识迁移

思路1:切片-拼接

需要占内存,遍历两次字符串

  1. 将S切成s[n:],s[:n]
  2. 拼接两部分s[n:]+s[:n],并返回

思路2: 定义字符串反转函数(剑指,更快)

调用3次reverse方法,reverse实则为首尾元素交换,然后首依次往后,尾依次往前,直到“首=尾”。

reverse方法复杂度0(1),列表按下标查找。

  1. 定义字符串所有字符都反转的函数 reverse(eg:abc->cba)
  2. 将字符串按第n位分割为两部分,分别进行 reverse
  3. 将反转后的两部分拼接后,再整体进行reverse

总结

  1. 字符串S无法直接按位交换,即s[i]=s[j]不合法;需S=list(S),再s[i]=s[j]即可。
# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if len(s)<n:
            return ''
        if len(s)==n:
            return s
        return s[n:]+s[:n]
# -*- coding:utf-8 -*-
class Solution:
    def reverse(self,s):
        if not s:
            return ''
        length = len(s)
        if length<=0:
            return ''
        s = list(s) #必须要有,不然不能使用s[i]=s[j]
        start = 0
        end = length-1
        while start<end:
            s[start],s[end]= s[end],s[start]
            start += 1
            end -= 1
        return ''.join(s)
    def LeftRotateString(self, s, n):
        # write code here
        length = len(s)
        if length<=0:
            return ''
        if n>length:
            n = n%length
        first = ''
        second = ''
        for i in range(n):
            first += s[i]
        for i in range(n,length):
            second += s[i]
        first = self.reverse(first)
        second = self.reverse(second)
        return self.reverse(first+second)

6.翻转单词顺序列

问题描述

一一的翻转字符串中所有单词的顺序,如将“I am a student.”翻转为“student. a am I”

考察点:知识迁移

思路:翻转函数reverse

  1. “整体翻转”:先将字符串中所有字符进行
  2. “局部翻转”:将字符串按空格进行分隔,每个单词分别翻转

总结

  • 字符串翻转时,需要按空格进行分词时,需记录首尾位置,不能直接用split(’ ')进行分割
# 错误,不能用split(' ')分隔字符串,翻转再拼接。因为“ ”测试不通过。
class Solution:
    def reverse(self,s):
        if not s:
            return ''
        length = len(s)
        if length<=0:
            return ''
        s = list(s) #必须要有,不然不能使用s[i]=s[j]
        start = 0
        end = length-1
        while start<end:
            s[start],s[end]= s[end],s[start]
            start += 1
            end -= 1
        return ''.join(s)
    def ReverseSentence(self, s):
        # write code here
        length = len(s)
        if length <=0:
            return ''
        if s ==" ":
            return " "
        s = self.reverse(s)
        s = s.split(' ')
        res = ''
        for i in s:
            i = self.reverse(i)
            res = res+i+' '
        return res.strip()
s = Solution()
s.ReverseSentence(' ')
'student. a am I'
class Solution:
    def reverse(self,s,start,end):
        if not s:
            return ''
        length = len(s)
        if length<=0:
            return ''
        s = list(s) #必须要有,不然不能使用s[i]=s[j]
        while start<end:
            s[start],s[end]= s[end],s[start]
            start += 1
            end -= 1
        return ''.join(s)
    def ReverseSentence(self, s):
        # write code here
        length = len(s)
        if length <=0:
            return ''
        #整体翻转
        s = self.reverse(s,0,length-1)
        #局部翻转
        st= 0
        e = 0
        i = 0
        while i<length:
            # 忽略单词开头的空格
            while i<length and s[i] == ' ':
                i += 1
            #记录非空格的第一个字符的位置
            st = i 
            e = i
            #找到第一个单词的结尾下标
            while i<length and s[i]!=' ':
                i += 1
                e += 1
            s = self.reverse(s,st,e-1)
        return s
s = Solution()
s.ReverseSentence('I am a student. ')            
' student. a am I'

7.把字符串转为整数

问题描述

  • 输入一个字符串,包括数字字母符号,可以为空
  • 如果是合法的数值表达则返回该数字,否则返回0

考察点:综合

思路

  • 首先判断首位,如果不是数字,则首位上字符的值为0;如果不是+/-,则数字非法,返回0。
  • 依次对其余位上的数求值,若遇到非数字,则数字非法,返回0.
  • 求和,返回。
class Solution:
    def StrToInt(self, s):
        # write code here
        if len(s)==0:
            return 0
        else:
            # 若首位非数字时,a=0
            if s[0]>'9' or s[0]<'0':
                a=0
                if s[0]!='+' and s[0]!='-':
                    return 0
            else:
                # 首位位数字,计算首位的值
                a=int(s[0])*10**(len(s)-1)
            if len(s)>1:
                for i in range(1,len(s)):
                    if s[i]>='0' and s[i]<='9':
                        a=a+int(s[i])*10**(len(s)-1-i)
                    else:
                        # 发现除首位外的位置上含非数字,则数值不合法,返回0
                        return 0
        if s[0]=='+':
            return a
        if s[0]=='-':
            return -a
        return a
s=Solution()
print s.StrToInt('+123')
print s.StrToInt('a123')
123
0

8.正则表达式匹配

问题描述

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

思路:

# -*- coding:utf-8 -*-
class Solution:
    # s, pattern都是字符串
    def match(self, s, pattern):
        # write code here
        if len(s)==0 and len(pattern)==0:
            return True
        if len(s)>0 and len(pattern)==0:
            return False
        # 当模式中的第二个字符是“*”时
        if len(pattern)>1 and pattern[1]=="*":
        #如果字符串第一个模式跟模式第一个字符匹配(相等或匹配到“.”),可以有3种匹配方式
            if len(s)>0 and (s[0]==pattern[0] or pattern[0]=='.'):
            #1.模式后移2字符,相当于x*被忽略
            #2.字符串后移1字符,模式后移2字符
            #3.字符串后移1字符,模式不变,即继续匹配字符下一位,因为*可以匹配多位
                return self.match(s,pattern[2:]) or self.match(s[1:],pattern[2:]) or self.match(s[1:],pattern)
            else:
                return self.match(s,pattern[2:])
        if len(s)>0 and (s[0]==pattern[0] or pattern[0]=='.'):
            return self.match(s[1:],pattern[1:])
        return False

9.表示数值的字符串

问题描述

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

思路1:正则表达式

  1. 是否匹配:re.match(r" ", mstr)
  2. ^:字符串的开始位置
  3. 特殊字符的匹配,需要加转译字符‘\’:$,(,),*,+,-,[,?,\,^,{,|。
  4. ?:匹配子表达式0次/1次;*:匹配子表达式0次/多次,+:匹配子表达式1次/多次。
# -*- coding:utf-8 -*-
import re
class Solution:
    # s字符串
    def isNumeric(self, s):
        # write code here
        return re.match(r"^[\+\-]?[0-9]*(\.[0-9]*)?([eE][\+\-]?[0-9]+)?$",s)

思路2:判断是否能转为float

  1. 能转为float的才为数字
# -*- coding:utf-8 -*-
class Solution:
    # s字符串
    def isNumeric(self, s):
        # write code here
        try:
            p = float(s)
            return True
        except:
            return False

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

问题描述

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

思路

  1. 方法1:遍历字符串,调用mstr.count(‘i’)查找mstr中‘i’出现的次数。
  2. 方法2:遍历字符串,用字典存储‘字符—次数’,之后再遍历字典,找到出现1次的字符。【较快】
  3. 方法3:遍历字符串,用列表mlist依次存储字符出现的次数。当字符已存在时,用mlist.index(‘i’)获取其下标后,令其值加1。【最快】
# 方法1
# -*- coding:utf-8 -*-
class Solution:
    # 返回对应char
    def __init__(self):
        self.mstr = ""
    def FirstAppearingOnce(self):
        # write code here
        for i in self.mstr:
            if self.mstr.count(i)==1:
                return i
        return '#'
    def Insert(self, char):
        # write code here
        self.mstr += char
# 方法2
# -*- coding:utf-8 -*-
class Solution:
    # 返回对应char
    def __init__(self):
        self.s=''
        self.dict1={}
    def FirstAppearingOnce(self):
        # write code here
        for i in self.s:
            if self.dict1[i]==1:
                return i
        return '#'
    def Insert(self, char):
        # write code here
        self.s=self.s+char
        if char in self.dict1:
            self.dict1[char]=self.dict1[char]+1
        else:
            self.dict1[char]=1
# 方法3
# -*- coding:utf-8 -*-
class Solution:
    chars = []
    counts = []
      
    def __init__(self):
        self.chars = []
        self.counts = []
      
    def FirstAppearingOnce(self):
        # write code here
        counter = 0
        while counter<len(self.counts):
            if self.counts[counter]==1:
                return self.chars[counter]
            counter += 1
        return "#"
          
    def Insert(self, char):
        # write code here
        if char in self.chars:
            self.counts[self.chars.index(char)] += 1
        else:
            self.chars.append(char)
            self.counts.append(1)

展开阅读全文

没有更多推荐了,返回首页