数据结构与算法部分题目(字符串）

最新推荐文章于 2024-05-15 13:55:28 发布

九日火

最新推荐文章于 2024-05-15 13:55:28 发布

阅读量711

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/weixin_42307828/article/details/84898643

版权

python 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

1.求数组中两个字符串的最小距离

题目：
给定一个数组 strs，其中的数据都是字符串，给定两个字符串 str1，str2。如果这两个字符串都在 strs数组中，就返回它们之间的最小距离；如果其中任何一个不在里面，则返回 -1；如果两个字符串相等，则返回 0。
例如：给定[‘*’,’3’,’*’,’5’,’10’,’9’,’7’,’1’,’*’]，再给定两个字符串’* ‘和’9’，通过函数求得返回值 3。
O(n**2)时间复杂度

def min_distance_1(strs, str1, str2):
    if str1 not in strs or str2 not in strs:
        return -1
    if str1==str2:
        return 0
    dist, min=1, len(strs)
    pos1, pos2=0, len(strs)
    for i in range(0, len(strs)):
        if str1==strs[i]:
            pos1=i
            for j in range(0, len(strs)):
                if str2==strs[j]:
                    pos2=j
                dist=abs(pos1-pos2)
                if dist<min:
                    min=dist
    return min

采用哈希表，O(1)时间复杂度

def min_distance_2(strs, str1, str2):
    if str1 not in strs or str2 not in strs:
            return -1
        if str1 == str2:
            return 0
        
        def create_hash(strs):
            strs_set=list(set(strs))
            dist_hash={}
            for i in range(0, len(strs_set)):
                temp={}
                for j in range(0, len(strs_set)):
                    if strs_set[i]!=strs_set[j]:
                        dist = min_distance_1(strs, strs_set[i], strs_set[j])
                        temp[strs_set[j]] = dist
                dist_hash[strs_set[i]] = temp
            return dist_hash

        return create_hash(strs)[str1][str2]

2.分解调整字符串中的字符

题目：
给定一个字符类型的数组 chas[]，其中只有数字和 “*”星型字符，现在想把所有的星型字符挪到数组的左边，数字字符全部放到右边，顺序不许变。

def replace_starts(str_list):
    j=len(str_list)-1
    for i in range(len(str_list), -1, -1):
        if str_list[i]!='*':
            str_list[j]=str_list[i]:
                j-=1
    for i in range(0, j+1):
        str_list[i]='*'
    return str_list

3.将字符串中的空字符全部替换为别的字符串

题目：
给定一个字符类型的数组 chas[]，其右半边全部是空字符，左半边没有空字符；现在需要将左半边所有的空格space替换为 “%20”，现在的假设是右半边足够大，不需要考虑这个空间。
例如：chas = [’ ‘,’a’,’ ‘,’b’,’ ‘,’ ‘,’g’]
输出的结果是 [‘%’, ‘2’, ‘0’, ‘a’, ‘%’, ‘2’, ‘0’, ‘b’, ‘%’, ‘2’, ‘0’, ‘%’, ‘2’, ‘0’, ‘g’]

def replace_space(self, str_list):  # 字符串的调整与替换,时间复杂度o(n),空间复杂度o(1)
        num = 1
        for i in xrange(0, len(str_list)):
            if str_list[i] == ' ':
                num += 1
        length = len(str_list) + 2 * num - 2
        i = k = len(str_list)
        while i < length:
            str_list.append('0')
            i += 1
        i -= 1
        for j in xrange(k-1, -1, -1):  # 逆序
            if str_list[j] == ' ':
                str_list[i] = "0"
                i -= 1
                str_list[i] = "2"
                i -= 1
                str_list[i] = "%"
                i -= 1
            else:
                str_list[i] = str_list[j]
                i -= 1
        return str_list

4.在有序但含有None的数组中查找字符串

题目：
给定一个字符串数组 str[]，其中有一些位置是 None，但在不是 None 的位置上，其字符串是按照字典的顺序由小到大依次出现的。再给定一个字符串 str，返回 str在 strs中出现最左的位置。
例如：
strs = [‘a’, None, ‘b’, None, ‘d’, ‘d’, None, ‘k’,’m’]
str = ‘d’
返回 4。
如果没有找到该字符，即不存在，或者str = None，都返回 -1

def get_index(alist, target):
    index=-1
    left=0
    right=len(alist)-1
    if target is None:
        return -1
    while left<=right:
        mid=(left+right)/2
        if alist[mid]==target:
            index=mid
            right=mid-1
        elif alist[mid]==None:
            i=mid-
            while left <= right:
            mid = (left + right) / 2
            if str_list[mid] == str:
                index = mid
                right = mid - 1
            elif str_list[mid] == None:
                i = mid - 1
                while 0 < i < mid:
                    if str_list[i] != None:
                        break
                    else:
                        i -= i
                if ord(str_list[i]) == ord(str):
                    index = i
                    right = i - 1
                elif ord(str_list[i]) > ord(str):
                    right = i
                else:
                    left = mid + 1
            else:
                if ord(str_list[mid]) > ord(str):
                    right = mid - 1
                else:
                    left = mid + 1
        return index

5.判断字符数组中是否所有的字符都只出现过一次

题目：
给定一个数组，判断其中所有的字符是不是都只出现过一次。

 def is_unique_1(self, str_list):  # 判断字符类型数组中的字符是否均只出现过一次，时间复杂度o(n)
        if str_list == "":
            return False
        i, map = 0, [0]
        while i < 256:
            map.append(0)
            i += 1
        for i in xrange(0, len(str_list)):
            map[ord(str_list[i])] += 1
            if map[ord(str_list[i])] != 1:
                return False
        return True

6.获取字符串的统计字符串

题目：
给定一个字符串 str，返回 str 的统计字符串。
例如：“fffjkk99999022____”，其统计字符串是“f_3_j_1_k_2_9_5_0_1_2_2___4”

def get_count_str(string):  # 获取字符串的统计字符串
        if string == "":
            return ""
        count = 0  # 计算某一种类型的字符的数量
        char = string[0]
        count_str = ""  # 存放统计字符串
        for i in range(0, len(string)):
            if char != string[i]:
                count_str += char + "_" + str(count) + "_"
                char = string[i]
                count = 1
            else:
                count += 1
        count_str += char + "_" + str(count)
        return count_str

7.将整数字符串转成整数值

题目
给定一个字符串，如果其中所有的字符都是数字，且符合人们日常的书写规范，则返回该整数值，否则返回0。
例如：“123”，返回123；
“038123”，返回0；
“dfa423”，返回0；
“-482”，返回-482；
“-03”，返回0。

def str_int(string):
    if string == "":
        return False
    if len(string)==1:
        if 48<ord(string)<=57:
            return string
        else:
            
            if string[0]=='-':
                if string[1]==0:
                    return 0
                else:
                    return string
            elif 48<ord(string[0])<=57:
                return string
            else:
                return 0

8.判断两个字符串是否互为旋转词

题目
如果将一个 str1 从任意的位置切分开，分成两部分，将后面一部分放置在前面，再组合起来成为 str2，构成了旋转词。
例如：str1 = “apple”，str2 = “leapp”，两个词就是旋转词.

def is_roatation(str1, str2):
    if str1=="" or str2=="" or len(str1)!=len(str2):
        return False
    return str1==str2[::-1]

9.去掉字符串当中的连续k个0

题目：
给定字符串str 和一个整数k。如果str中恰好出现了连续的k个0，则将k个0删除。
比如，给定字符串str = “0000fw300001203h000ui0000re3_0000”，k=4。返回的结果为“fw31203h000uire3_”。

def remove_k_zeors(string, k):
    a=str(0)*k
    return string.replace(a, '')

10.计算字符串中所有数字之和

题目：
给定一个字符串，计算其中所有数字的和。其中，不考虑小数点，如果有奇数个“-”号，则数字为负，偶数个则数字为正。
例如，“a12b3mnh4”, 返回值19，
“-2fds—-43fnd”，返回值41。

def sum_of_num(string):
    sum, num, pos=0, 0, 1
    if string == " ":
        return 0
    for i in range(0, len(string)):
        if 0<=string[i]<=9:
            num=num*10+int(string[i])*pos
        else:
            sum+=num
            num=0
            if string[i]='-':
                if i-1>1 and string[i-1]="-":
                    pos=-pos
                else:
                    pos=-1
            else:
                pos=1
    sum+=num
    return sum

11.判断两字符串是否互为变形词

题目：
给定两个字符串，str1，str2，判断两个字符串中出现的字符是否全部种类一样，数量一样。
例如：
str1 = “apple”, str2 = “paple”, 返回 True;
str1 = “pear”, str2 = “bears”, 返回 False。

def is_deformation(str1, str2):
    if str1 is None or str2 is None or len(str1) != len(str2):
        return False
    i, map = 0, [0]
    while i <= 256:
        map.append(0)
        i += 1
    for i in range(0, len(str1)):
        map[ord(str1[i])] += 1
    for i in range(0, len(str2)):
        if map[ord(str2[i])] == 0:
            return False
    return True

12.Anagrams 归类

题目
给出一组字符串，返回其中所有的 Anagrams。
比如，给出 [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]，
返回
[
[“ate”, “eat”,”tea”],
[“nat”,”tan”],
[“bat”]
]
所有字母不分大小写。

def group_anagrams(strings):
    dict_1, ans={}, []
    for i in strings:
        i=i.lower()
        sort_str=''.join(sorted(i))
        if sort_str in dict_1:
            dict_1[sort_str]+=[i]
        else:
            dict_1[sort_str]=[i]
    
    for i in dict_1:
        tmp=dict_1[i]
        ans+=[tmp]
    return dict_1, ans

13.括号字符串的相关问题

题目：
1、给定一个字符串，判断这个字符串是不是有效的括号字符串，也就是满足数学算式可算性。比如，str=”(()(())())”,返回 True，给定str = “(()((())(())”，返回False。如果括号字符串中掺杂了其它的字符，则返回False
2、给定一个括号字符串，找出其中最大的子串长度，比如：给定str = “(()((())(())”，返回 8。

def brackets_is_valid_1(str):
        '''
        判断括号字符串是不是有效括号字符串，比如："()()"为 True，"(()())"为 True，"())"，"（())"等等均为 False
        方法1：建立一个栈操作,时间复杂度为一遍遍历，但是空间复杂度较高。
        :param str: 括号字符串
        :return: True 或者 False
        '''
        stack = []
        for i in xrange(0, len(str)):
            if str[i] != "(" and str[i] != ")":
                return False
            if str[i] == "(":
                stack.append("(")
            else:
                stack.pop()
        if stack != []:
            return False
        else:
            return True


def brackets_is_valid_2(str):
        '''
        判断括号字符串是不是有效括号字符串，比如："()()"为 True，"(()())"为 True，"())"，"（())"等等均为 False
        方法2：时间复杂度不变，仍是一遍遍历的，但是空间复杂度只有o(1)。
        :param str: 括号字符串
        :return: True 或者 False
        '''
        num1, num2 = 0, 0
        for i in xrange(0, len(str)):
            if str[i] != "(" and str[i] != ")":
                return False
            if str[i] == "(":
                num1 += 1
            else:
                num2 += 1
            if num1 < num2:
                return False
        if num1 == num2:
            return True
        else:
            return False

 def longest_sub_brackets(str):
        '''
        给定一个括号字符串 str，返回最长的有效括号字符串
        方法：动态规划求解，做到时间复杂度 o(n)，空间复杂度 o(n)。创建一个与字符串同等长度的数组 dp[]，
            其含义是对应 str[i]结尾的字符串的最长有效子串的长度。然后即可开始求解。
        :param str: 给定的括号字符串
        :return: 最长有效子串
        '''
        print str
        dp = []
        for _ in xrange(0, len(str)):
            dp.append(0)
        for i in xrange(0, len(str)):
            if str[i] == "(":
                dp[i] = 0
            if str[i] == ")":
                if i != 0:
                    pre = i - dp[i-1] - 1
                    if str[pre] == "(":
                        dp[i] = dp[i-1] + 2 + dp[pre-1]
        return max(dp)