题目篇03

1. 给两个字符串s和t，判断t是否为s重新排列后组成的单词

• s="anagram"  t="nagaram"   return True
• s="rat"    t="car"     return False

 看两个字符串中每个字母数字是否一样：用字典，字典没有顺序

def isAnagram(self,s,t):
    # 用两个字典来存放s和t中元素及其个数
    dict1={}   # {'a':3,'b':2}
    dict2={}
    for ch in s:
        dict1[ch]=dict1.get(ch,0)+1
    for ch in t:
        dict2[ch]=dict2.get(ch,0)+1
    return dict1 == dict2   # 字典没有顺序

# 自己思路
def judge_st(s,t):
    if len(s)!=len(t):
        return False
    else:   # 长度相同
        list_s=list(s)
        list_t=list(t)
        for item in list_s:
            # 如果item在list_t中
            if item in list_t:
                list_t.remove(item)
            else:   # a=False,item在s中不在t中
                return False

        if len(list_t)==0:    # s是t的重组单词
            return True
        else:
            return False

s1="anagram"
t2="nagaram"
print(judge_st(s1,t2))

改进： 时间复杂度O(nlog n)

def func(s,t):
    ss=list(s)   # 字符串转换为列表
    tt=list(t)
    ss.sort()    # 给ss、tt排序
    tt.sort() 
    return ss==tt

def func(s,t):
    return sorted(list(s))==sorted(list(t))

 

2. 给一个m*n的二维列表，查找一个数是否存在。列表有下列特性：

• 每一行的列表从左到右已经排序好
• 每一行第一个数比上一行最后一个数大

• 

  时间复杂度太高，二分法的应用改进：

# 一个二维数组中是否存在一个数
def searchMatrix(self,matrix,target):
    rows=len(matrix)
    if rows == 0:  # []
        return False
    cals = len(matrix[0])
    if cals == 0:  # [[] [] []]
        return False

    left = 0
    right = rows*cals-1

    while left <= right:
        mid = (left+right)//2
        i = mid//cals
        j = mid % cals
        if matrix[i][j] == target:
            return True
        elif matrix[i][j] > target:
            right = mid-1
        else:  # matrix[i][j] < target
            left = mid+1
    else:
        return False

 

# 一个二维数组中是否存在一个数
def searchMatrix(self,matrix,target):
    for line in matrix:
        if target in line:
            return True
    return False

# 自己思路：
# 二分法：
def binary_search(li,val):
    left=0
    right=len(li)-1
    while left<=right:
        mid=(left+right)//2
        if li[mid]==val:
            return True
        elif li[mid]>val:
            right=mid-1
        elif li[mid]<val:
            left=mid+1
    else:
        return False

# 在每一行line中做二分查找
def li_binary_search(li,val):
    for item in li:
        if binary_search(item,val):
            return True
    else:
        return False

list1=[[1,2,3],[4,5,6],[7,8,9]]
print(li_binary_search(list1,22))

3. 给定一个列表和整数，设计算法找到两个数的下标，使得两个数之和为给定的整数。保证肯定仅有一个结果。

• 例如，列表【1，2，5，4】与目标整数3，1+2=3，结果为（0，1）

  从左到右查找时，在第一个数为x时，另一个数等于 target - x ,只需要找到 target-x 的下标---二分法查找。

# 先将其排序，再二分法查找，但是还要保存排序之前的下标
def twoSum(nums,target):
    new_nums=[[num,i] for i,num in enumerate(nums)]
    new_nums.sort(key=lambda x:x[0])
    for i in range(len(new_nums)):
        a=new_nums[i][0]
        b=target-a
        # j=binary_search(new_nums[i+1:],b)   # 用二分法在 i 位置后面查找b，切片操作复杂度高，改进
        j = binary_search(new_nums, i+1, len(new_nums), b)
        if j:   # 如果找到b就退出
            break
    return sorted(new_nums[i][1],new_nums[j][1])


# 二分法：
def binary_search(li,left,right,val):
    while left<=right:
        mid=(left+right)//2
        if li[mid]==val:
            return True
        elif li[mid]>val:
            right=mid-1
        elif li[mid]<val:
            left=mid+1
    else:
        return False

# 自己思路：
def func1(li,val):
    n=len(li)
    i=0
    while i<n:
        for j in range(i+1,n):
            if li[i]+li[j]==val:
                return i,j
        i+=1

list1=[1,2,4,5]
print(func1(list1,5))