算法

# lowB三人组
# 时间复杂度：O(n**2)
# 空间复杂度：O(1)


# # 冒泡算法
# def bubble_sort(li):
#     for i in range(len(li)-1):
#         exchange = False  # 如果这一趟没有发生交换，就结束排序
#         for j in range(len(li)-i-1):
#             if li[j]>li[j+1]:
#                 li[j],li[j+1] = li[j+1],li[j]
#                 exchange = True
#         if not exchange:
#             return li
#
#
#
#
# li = [1,3,5,2,88,45,225]
# print(bubble_sort(li))
#





# # 选择排序思路：
# # 分有序区和无序区，一趟便利最小的数放在有序区第一的位置，
# # 再继续遍无序区中元素最小的继续放置在有序曲，直到全部有序

# def select_sort(li):
#     for i in range(len(li)-1):
#         min_loc = i
#         for j in range(i+1,len(li)):
#             if li[j]<li[min_loc]:
#                 min_loc = j
#         if min_loc != i:
#             li[i],li[min_loc] = li[min_loc],li[i]
#     return li
#
# li = [1,3,5,2,88,45,225]
# print(select_sort(li))



# 插入排序
# 列表被分为有序区和无序区两部分，开始有序区只有一个元素
# 每次在无序区取一个元素插入到有序曲，只到无序区为空

# def insert_sort(li):
#     for i in range(1,len(li)):
#         tmp = li[i]
#         j = i-1
#         while j >= 0 and tmp < li[j]:
#             li[j+1]=li[j]
#             j = j-1
#         li[j+1] = tmp
#     return li
#
#
# li = [1,3,5,2,88,45,225]
# print(insert_sort(li))



# 快排：
# 时间复杂度：
# 最坏:O(n**2)
# 一般：O(nlogn)
# 空间复杂度：
# 平均：O(logn)
# 最坏：O(n)

# 取一个元素p使其归位（第一个元素）
# 列表被p分成两部分，左边都比p小，右边都比p大
# 递归完成排序


# def partition(data,left,right):
#
#     tmp = data[left]
#     while left < right:
#         # right 左移动
#
#         while left < right and data[right] >= tmp:   #如果low和high没有相遇且后面的数一直大于第一个数 就循环
#             right -=1
#         data[left] = data[right]
#         # left 右移动
#         while left < right and data[left] <= tmp:   #如果low和high没有相遇且后面的数一直大于第一个数 就循环
#             left +=1
#         data[right] = data[left]
#     data[left] = tmp
#     return left
#
#
# def quick_sork(data,left,right):
#
#     if left <right:
#         mid = partition(data,left,right)
#         quick_sork(data,left,mid-1)
#         quick_sork(data,mid+1,right)
#     return data
#
#
# alist = [33,22,11,55,33,666,55,44,33,22,980]
#
# obj = quick_sork(alist,0,len(alist)-1)
# print(obj)


# 二分算法：

# def bin_search(li,val):
#     low = 0
#     high = len(li) - 1
#     while low <= high:
#         mid = (low + high) // 2
#         if li[mid] == val:
#             return mid
#         elif li[mid] < val:
#             low = mid + 1
#         else:
#             high = mid - 1
#     return None


# 两个数相加等译一个固定的数，求两个数索引

# def two_sum_3(li, target):
#     li.sort()
#     i = 0
#     j = len(li) - 1
#     while i < j:
#         sum = li[i] + li[j]
#         if sum > target:
#             j -= 1
#         elif sum < target:
#             i += 1
#         else:  # sum==target
#             return (i, j)
#     return None

# def two_sum(li, target):
#     l = len(li)
#     for i in range(l):
#         for j in range(i + 1, l):
#             if li[i] + li[j] == target:
#                 return (i, j)
#     return None
# 
# 
# print(two_sum([2, 7, 11, 15], 17))

 

获取字符串str1和str2最长公共子串的长度与起始位置

def getLongestSubstring(str1,str2):
    longest=0
    start_pos1=-1
    start_pos2=-1
    compares=0   # 记录比较次数

    for i in range(len(str1)):
        for j in range(len(str2)):
            length=0
            m=i
            n=j
            while str1[m]==str2[n]:
                compares+=1
                length+=1
                m+=1
                n+=1
                if (m>=len(str1))|(n>=len(str2)):
                    break
            if longest<length:
                compares+=1
                longest=length
                start_pos1=i
                start_pos2=j
    return longest,start_pos1,start_pos2,compares

　　

给出一个非负整数 num，反复的将所有位上的数字相加，直到得到一个一位的整数。 

  def addDigits(self, num):
        # Write your code here
        if num<10:
            return num
        a=str(num)
        while len(str(a))>1:        
            b=0
            for i in range(len(a)):
                b+=int(a[i])
            a=str(b)
        return b