python 列表操作

字符串匹配，判断一个字符串是否是另一个的子串

s='abcdeabcef'

p1='abce' #p1是s的字串
print(p1 in s) #返回 True
print(s.find(p1)) #输出 5

p2='abef' #p2 不是s的字串，注意，字符得是连续出现的，串是一个整体
print(p2 in s) #返回 False
print(s.find(p2)) #s不存在子串p2 时会返回 -1

python中sum有点不一样

num1=10
num2=5
#print(sum(num1,num2)) #TypeError: 'int' object is not iterable
#正解
lst=[]
lst.append(num1)
lst.append(num2)
print(sum(lst)) 
            

python的二维数组有点不一样

1、二维数组长度是里面包含的的一维数组个数

2、判断某个元素是否在二维数组中，应该用for循环对每一个内层一维数组判断

lis=[[2,3],[4,5],['a','b']]
print("二维数组为：",lis)
i=2
#二维数组长度是里面包含的的一维数组个数
print("二维数组长度为:",len(lis))
print("i 是否在二维数组中：",i in lis)
#判断某个元素是否在二维数组中，应该用for循环对每一个内层一维数组判断

def exist(x):
    for i in range(len(lis)):
        if x in lis[i]:
            return True
    return False

print(exist(5))
print(exist(7))
print(exist('a'))
        

连续子数组最大和，精妙解法

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

def FindGreatestSumOfSubArray(array):
    maxsum=sum(array)
    tempsum=0
    for i in array:
        #如果i前面的和小于0，那么前面的肯定不可能在最大连续数组中了，直接从i开始加，即i作为第1项
        if tempsum<=0: 
            tempsum=i
        else:
            tempsum+=i  
            #存储起来最大值，如果 i是大于0，tempsum肯定变大了，maxsum也就变大了，
            #如果i小于0，也没事啊，maxsum 不变，还是原来的最大值
        if tempsum>maxsum: 
            maxsum=tempsum
    return maxsum
        
        
a1=[-1,2,3,4,-5,6]
a2=[-1,-2,-3,-4,-5]
a3=[2,3,-4,5,-6,7,-11]
print(FindGreatestSumOfSubArray(a1))
print(FindGreatestSumOfSubArray(a2))
print(FindGreatestSumOfSubArray(a3))

反转链表

输入一个链表，反转链表后，输出新链表的表头。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        if not pHead or not pHead.next:
            return pHead
        last = None
        while pHead:
            tmp = pHead.next
            pHead.next = last
            last = pHead
            pHead = tmp
        return last

乱序字符串检查

乱序字符串是指一个字符串只是另一个字符串的重新排列。例如，‘heart’ 和 ‘earth’ 就是乱序字符串。‘python’ 和 ‘typhon’ 也是。为了简单起见，我们假设所讨论的两个字符串具有相等的长度（因为不同长度肯定不是）并且他们由 26 个小写字母集合组成。

解决方案一

判断字符串s1的每个字符是否都能在s2中找到，若找不到，返回False ；若找到了，将s2对应的字符换为None ，必须替换，因为若有重复字符，必须保证该字符出现次数也一样。继续找s1 的下一个字符，直到找完 s1的所有字符。但是字符串是不可变类型，因此，要先将字符串s2转换成列表。

def Solution(s1,s2):
    lst=list(s2)
    len1,len2=len(s1),len(s2)
    i=0
    while i<len1:
        j=0
        found=False
        while j<len2 and not found: 
            if s1[i]==lst[j]:
                found=True 
                lst[j]=None
            else:     #没找到继续找
                j+=1
        if found:    #当前字符找到了，则继续寻找下一个
            i+=1
        else:        #出现找不到的字符，肯定不是乱序字符串
            return False 
    return True
            
print(Solution('earth','heart')) #True
print(Solution('earthw','heart')) #False
print(Solution('eearth','heart')) #False
print(Solution('earthy','heartx')) #False
print(Solution('abecde','edcbae')) #True

不难看出，这个算法复杂度为 O(n^2 )。

解决方案二

两个字符串如果是乱序字符串，则经过排序之后肯定是一样的，因此，直接先对两个字符串先进行排序，再判断是否相等即可。注意字符串下是不可变类型，下面的代码是错误的写法，编译都会报错的

"""
s1='dcba'
t1=s1.sort() #错误写法
t1=s1.sorted() #错误写法
print(t1)
"""

所以，应该先将连个字符串转化为列表

def Solution(s1,s2):
    t1=list(s1)
    t2=list(s2)
    
    t1.sort()
    t2.sort()
    return t1==t2

这个算法，判断t1、t2是否相等，只要遍历两个列表即可，O(n)，调用排序算法，内置的排序算法是快速排序，事件复杂度为 O(nlog n)

解决方案三：使用计数器

两个字符串如果是乱序字符串，那它们中的每个字母出现的次数应该是一样的，因此用两个列表分别存储两个字符串中各个字母出现的次数，再比较这两个计数器列表是否相等即可

def anagramSolution(s1,s2):
    c1=[0]*26
    c2=[0]*26
    
    for i in range(len(s1)):
        pos=ord(s1[i])-ord('a')
        c1[pos]+=1
    for i in range(len(s2)):
        pos=ord(s2[i])-ord('a')
        c2[pos]+=1
        
    j=0
    flag=True
    for i in range(26):
        if c1[i]!=c2[i]:
            flag=False
    return flag

print(anagramSolution('pleap','apple')) #True
print(anagramSolution('pleap','applep')) #False
print(anagramSolution('ple','apple')) #False

这个方案有多个迭代，但是和第一个解法不一样，它不是嵌套的。两个迭代都是 n, 第三个迭代，比较两个计数列表，需要 26 步，因为有 26 个字母。一共T(n)=2n+26T(n)=2n+26，即 O(n)

返回字符串中第一个出现次数为1的字符

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.

解法一：字符转ASCII码 求次数，再遍历字符串个字符出现次数

• python 内置函数 ord(‘ch’) :字符转成对应的ASCII码
• python 内置函数 chr(‘number’) :数字转换成该ASCII码值对应的字符

 def FirstNotRepeatingChar(self, s):
        lis=list(ord(i)-65 for i in s)
        count=[0]*68 #各字符出现次数
        for i in lis:
            count[i]+=1
        for j in range(len(s)):
            if count[ord(s[j])-65]==1:
                return j
        return -1

解法二：利用字符串内置方法快速解决

def FirstNotRepeatingChar(self, s):
        for i in s:
            if s.count(i)==1:
                return s.index(i)
        return -1

数组转字符串

lst=['a','b','c','d']
string="".join(lst)
print(string)