python算法学习（10）——查找排序练习题

练习题1

题目：
给出两个字符串s和t，判断t是否为s的重新排列后组成的单词：
①s=“anagram”，n=“nagaram” ， return True
②s=“rat”，n=“car” ， return None

思路(用排序思想)：
①首先判断两字符串长度是否相等，若不相等直接返回False，若相等则继续向下执行；
②将两个字符串放进列表里，分别进行排序（按字母从小到大）
③排序后，若两列表相等，则返回True，否则返回False
代码如下：

##练习题1（用排序思路)
#第一种————时间复杂度为O（nlogn）
def exercises1_1(s,t):
    '''
    :param s: str
    :param t: str
    :return: bool
    '''
    ss=list(s)
    tt=list(t)
    ss.sort()
    tt.sort()
    return ss==tt

#第二种————时间复杂度为O（nlogn）
def exercises1_2(s,t):
    '''
    :param s: str
    :param t: str
    :return: bool
    '''
    return sorted(list(s))==sorted(list(t))

#第三种(用字典类似计数排序)————时间复杂度为O（n）
def exercises1_3(s,t):
    '''
    :param s: str
    :param t: str
    :return: bool
    '''
    dict1={}  #{'a':1,'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 dict2==dict1

练习题2

题目：
给定一个m*n的二维列表，查找一个数是否存在，返回True或False。列表有以下特性：
①每行列表从左到右已排好序；
②每一行第一个数比上一行最后一个数大。
如图中二维列表：

思路：
①每行一个一个查找（类似顺序查找）
②二分查找
代码如下：

##练习题2（用排序思路)
#第一种————时间复杂度为O（nm）
def exercises2_1(tlist,val):
    '''
    :param tlist: list[list[int]]
    :param val: int
    :return: bool
    '''
    for line in tlist:
        if val in line:
            return True
    return  False

#第二种————时间复杂度为O（logn）
def exercises2_2(tlist,val):
    '''
    :param tlist: list[list[int]]
    :param val: int
    :return: bool
    '''
    h=len(tlist)
    if h ==0:
        return False
    w=len(tlist[0])
    if w==0:
        return False
    left=0
    right=w*h-1
    while left<=right:
        mid=(left+right)//2
        i=mid // w
        j=mid % w
        if tlist[i][j]==val:
            return  True
        elif tlist[i][j]>val:
            right=mid-1
        else:
            left=mid+1
    else:
        return False

练习题3

题目：
给定一个列表和一个整数，设计算法找到两个数的下标，使两个数之和为给定整数，且保证肯定只有一个结果
例如：列表[1,3,5,7,6]和目标整数4，1+3=4，则结果返回[0，1]
思路：
①双指针（两层for循环）
②二分查找
代码如下：

##练习题3（用排序思路)
#第一种————时间复杂度为O（n²）
class Solution:
    def exercises3_1(self, list, val):
        '''
        :param list: list[int]
        :param val: int
        :return: list[int]
        '''
        n=len(list)
        for i in range(n):
            for j in range(i+1,n):
                if list[i]+list[j]==val:
                    return sorted([i,j])

#第二种————时间复杂度为O（）

    def binary_search(self, li, left, right, val):
        while left <= right:
            mid = (left + right) // 2
            if li[mid][0] == val:
                return mid
            elif li[mid][0] > val:
                right = mid - 1
            else:
                left = mid + 1
        return None

    def exercises3_2(self, list, val):
        '''
        :param list: list[int]
        :param val: int
        :return: list[int]
        '''
        new_lists = [[num, i] for i, num in enumerate(list)]
        new_lists.sort(key=lambda x: x[0])
        for i in range(len(list)):
            a = new_lists[i][0]
            b = val - a
            if b >= a:
                j = self.binary_search(new_lists, i + 1, len(new_lists) - 1, b)
            else:
                j = self.binary_search(new_lists, 0, i - 1, b)
            if j:
                break
        return sorted([new_lists[i][1], new_lists[j][1]])