2019-2-变位词

2019-12-16-变位词

几种不同算法的实现：

1: 逐个单词检查

# -*- coding: utf-8 -*-

"""
问题描述：
    所谓“变位词”是指两个词之间存在组成字母的 重新排列关系
    （组成单词的字母一样，但是排列顺序不同）
例如： s1: abc 
       s2: cba

#Way 1: 逐个单词检查

算法：
    s1串从开始位置，第一字符在s2中匹配，
    匹配成功： s2匹配的位置，设置为空，s1继续下一个字符
    匹配不成功： 结束
算法分析：
    外层循环遍历s1每个字符，将内层循环执行n次
    而内层循环在s2中查找字符，每个字符的对比次 数，分别是1、2…n中的一个，而且各不相同
数量级别：O(n2）

"""
def way_one(s1,s2):
    t_s2=list(s2)    # 将s2 复制给t_s2
    index1 =0        # s1的下标
    flag =True       # s1 s2 是变位词flag =True 否 False
    while index1<len(s1) and flag:
        index2 = 0  # s2的下标
        found=False
        while index2 <len(t_s2) and not found:
            if s1[index1] == t_s2[index2]:
                found =True         #在s2中找到s2[index1] 退出
            else:
                index2=index2+1     #s2 继续向后查找
        if found:
            t_s2[index2]=None       #将s2中找到的元素标记为空
        else:
            flag=False #如果在s2中找不到与s1[index1]匹配的元素，结束
            return flag
        index1 =index1+1
    return flag

 2: 排序检查

#Way 2: 排序检查
"""
算法：
    将两个字符串按照字母表顺序排序，然后在逐个对比
    如果有一个不同，就不是变为词
    直到程序结束
算法分析：
    此算法复杂度主要在排序上，给我们一个思想，在处理问题时，可以先考虑排序。
    或者在一开始设计程序时，就将数据按照一定的顺序存储。
数量级别：
    排序复杂度O(nlogn)
    依次对比，O(n)

"""
def way_two(s1,s2):
    t_s1=list(s1)   #将s1 s2字符串转成列表
    t_s2=list(s2)
    t_s1.sort()     #将s1,s2排序
    t_s2.sort()
    index=0         #下标
    flag=True
    while index<len(s1) and flag:
        if t_s1[index]==t_s2[index]:
            index+=1
        else:
            flag=False
    return flag

3: 计数比较

#Way 3:  计数比较
"""
算法：
    对比两个词中每个字母出现的 次数，如果26个字母出现的次数都相同的 话
    ，这两个字符串就一定是变位词
算法分析：
    此算法相对于一个map: key-value ,一个字符一个key,value从0开始计数
数量级别：
    总操作次数T(n)=2n+26
    O（n）
"""
def way_three(s1,s2):
    c1=[0]*26
    c2=[0]*26
    for i in range(len(s1)):
        pos=ord(s1[i])-ord('a')
    for i in range(len(s2)):
        pos=ord(s2[i])-ord('a')
    j=0
    flag=True
    while j<26 and flag:
        if c1[j]==c2[j]:
            j+=1
        else:
            flag=False
    return flag

4： 暴力法：

全排列（详细看2019-3-全排列）

# Way4 暴力法
"""
算法：
     将字符串中的所有字符全排列 ，然后比较s2 是否在全排列之中
数量级别：
    全排列 n!
算法复杂度 2^n

"""
temp=[]                                #保存全排列临时列表
def permutations1(arr,left,right):       #递归全排列
    if left==right:                     #递归结束条件          
        arr2=list(arr)                  #不在转一次，temp.append() 方法覆盖前面，加这句另开辟一个存储空间
        temp.append(arr2)                   #将每一个排列结果，放到temp中
    else :
        for i in range(left,right):
            arr[i],arr[left] =arr[left],arr[i]  #交换相邻两个数
            permutations1(arr,left+1,right)
            arr[i],arr[left] =arr[left],arr[i]
def way_four(s1,s2):             
    t_s1=list(s1)              #将s1转成列表
    t_s2=list(s2)
    permutations1(t_s1,0,len(t_s1))  
    return t_s2 in temp       #判断s2 是否在全排列中
#测试
s1='abcd'
s2='cbda'
print(way_four(s1,s2))