算法面试其他篇
目录：
1.1 简单数组题
1、去除列表中相加等于指定数后的列表(x+y=4)
[1,3,5,7,1,2] ==> [5,7,1,2] [1,3,3,5,7,1,2] ==> [3,5,7,1,2]
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def func(l, tag=4):
for i in range(len(l)):
a = l[i]
if a != None:
b = tag - a
try:
index = l.index(b)
if index != i: # 避免 2 + 2 = 4只有一个2也没重置为None
l[i] = None
l[index] = None
else:
if l.count(b) > 2: # 如果有两个就都重置为 None
l[i] = None
l[l.index(b)] = None
except Exception as e:
pass
print l # [None, None, 5, 7, 1, 2]
while None in l:
l.remove(None)
return l # [5, 7, 1, 2]
l = [1,3,5,7,1,2]
print func(l, 4)
'''
[1,3,5,7,1,2]
[None, None, 5, 7, 1, 2]
[5, 7, 1, 2]
'''
2、合并两个有序列表
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def loop_merge_sort(l1, l2):
tmp = []
while len(l1) > 0 and len(l2) > 0:
if l1[0] < l2[0]:
tmp.append(l1[0])
del l1[0]
else:
tmp.append(l2[0])
del l2[0]
tmp.extend(l1)
tmp.extend(l2)
return tmp
l1 = [1,4,5]
l2 = [2,3,6]
print loop_merge_sort(l1, l2) # [1, 2, 3, 4, 5, 6]
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def loop_merge_sort(l1, l2):
n1, n2 = 0, 0
len1, len2 = len(l1), len(l2)
tmp = []
while n1 < len1 and n2 < len2:
if l1[n1] < l2[n2]:
tmp.append(l1[n1])
n1 = n1 + 1
else:
tmp.append(l2[n2])
n2 = n2 + 1
else:
while n1 < len1:
tmp.append(l1[n1])
n1 = n1 + 1
while n2 < len2:
tmp.append(l2[n2])
n2 = n2 + 1
return tmp
l1 = [1,4,5]
l2 = [2,3,6]
print loop_merge_sort(l1, l2) # [1, 2, 3, 4, 5, 6]
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def find_kth(l1, l2, k):
val = None
n = 1
while len(l1) > 0 and len(l2) > 0: # l1和l2都未取到最后一个数
if l1[0] < l2[0]:
val = l1[0]
del l1[0]
else:
val = l2[0]
del l2[0]
if n == k:
return val
n = n + 1
while len(l1) > 0: # l2为空，l1不为空
val = l1[0]
del l1[0]
if n == k:
return val
n = n + 1
while len(l2) > 0: # l1为空l2不为空
val = l2[0]
del l2[0]
if n == k:
return val
n = n + 1
l1 = [1,4,5,11,12,13,18]
l2 = [2,3,6,7,8,9,10]
print find_kth(l1, l2, 14) # 18
3、一个有序列表找中位数
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def get_median(data):
data.sort()
half = len(data) // 2
return (data[half] + data[-1-half]) / float(2)
data = [1,2,3,4,5,6,7,8,9,10,11,12]
print get_median(data)
4、找素数(除了1和他本身没有其他的约数)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import math
def func(n):
l = []
for i in range(2, n+1):
for j in range(2, int(math.sqrt(i))+1):
if i%j == 0: #如果出现整除说明有因子
break #跳出最外层for循环判断下一个
else: #如果第二层循环结束还没有跳出的话
l.append(i) #说明是素数，加到列表里
return l
print func(20) # [2, 3, 5, 7, 11, 13, 17, 19]
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import math
def func(n):
l = [2,3,5]
for i in range(6, n+1):
for j in l:
if j <= ( math.sqrt(i) + 1 ) and i%j == 0:
break #跳出最外层for循环判断下一个
else: #如果第二层循环结束还没有跳出的话
l.append(i) #说明是素数，加到列表里
return l
print func(10) # [2, 3, 5, 7]
'''
说明：判断100是否是质素只需要对比4次
1、不需要循环[1,2,3,4,5,6,7,8,9,10]依次与100取余
2、只需要循环[2, 3, 5, 7] 依次与100取余即可
'''
5、列表去重
#1、set去重
a=[1,2,3,4,1,2,3,4]
print( list(set(a)) ) # [1, 2, 3, 4]
#2、使用字典去重
b = {}
b=b.fromkeys(a).keys()
print(list(b)) # [1, 2, 3, 4]
a=[1,2,3,4,1,2,3,4]
#1、去重不改变顺序
d = {}
tmp = []
for i in a:
if not d.get(i):
tmp.append(i)
d[i] = True
print(tmp) # [1, 2, 3, 4]
6、实现enumerate函数
l = [1,2,3,4]
def my_enumerate(l):
n = 0
for val in l:
print(n,val)
n += 1
my_enumerate(l)
7、求两个列表 交集、差集、并集
list_1 = set([1,2,3,4,5])
list_2 = set([4,5,6,7,8])
#1、交集（在list_1和list_2中都有的元素4,5）
print(list_1.intersection(list_2)) #交集： {4, 5}
#2、差集
print(list_1.difference(list_2)) #差集：在list_1中有在list_2中没有： {1, 2, 3}
print(list_2.difference(list_1)) #差集：在list_1中有在list_2中没有： {8, 6, 7}
#3、并集（在list_1和list_2中的元素全部打印出来，重复元素仅打印一次）
print(list_1.union(list_2)) #并集： {1, 2, 3, 4, 5, 6, 7, 8}
8、求股票最大利润
def maxProfit(prices):
min_p, max_p = max(prices), 0
for i in range(len(prices)):
min_p = min(min_p, prices[i]) # 到目前为止最小买入价格
max_p = max(max_p, prices[i] - min_p) # 最大利润 = 当天价格 - 历史最小价格
return max_p
l = [7,1,5,3,6,4]
print(maxProfit(l)) # 5
1.2 找两个有序列表中位数（难）
1、找中位数（两个列表）
参考博客：https://www.jb51.net/article/152061.htm
参考官网：https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/
1）给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。
2）请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def median(A, B):
m, n = len(A), len(B)
if m > n:
A, B, m, n = B, A, n, m
if n == 0:
raise ValueError
imin, imax, half_len = 0, m, (m + n + 1) / 2
while imin <= imax:
i = (imin + imax) / 2
j = half_len - i
if i < m and B[j-1] > A[i]:
# i is too small, must increase it
imin = i + 1
elif i > 0 and A[i-1] > B[j]:
# i is too big, must decrease it
imax = i - 1
else:
# i is perfect
if i == 0: max_of_left = B[j-1]
elif j == 0: max_of_left = A[i-1]
else: max_of_left = max(A[i-1], B[j-1])
if (m + n) % 2 == 1:
return max_of_left
if i == m: min_of_right = B[j]
elif j == n: min_of_right = A[i]
else: min_of_right = min(A[i], B[j])
return (max_of_left + min_of_right) / 2.0
nums1 = [1,2,4]
nums2 = [3,5,6]
print median(nums1, nums2) # 3.5
1.3 从无序列表查找数组第K大的数(O(n))
参考博客：https://blog.csdn.net/wenqiwenqi123/article/details/81669899
1、原理分析
1. 利用快排每次循环可以将元素分为左侧都比自己小，右侧都比自己大的思想
2. 找到k大概的位置，每次去一半即可
3. 为什么时间复杂度是O(n)而不是nlog(n)
1) 第一次排序需要遍历所有元素，时间复杂度为：n
2）第二次排序数量只有上次的一半：n/2
3) 所以总时间复杂度： n + n/2 + n/4 + n/8 + ...... + < 2n
注：这种方法如果又重复元素很容易导致死循环
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def partition(num, low, high):
cur = num[low]
while low < high:
while low < high and num[high] > cur: # 从右向左比，直到遇到右边一个元素小于cur为止
high -= 1
while low < high and num[low] < cur: # 从左向右比，直到遇到左边一个元素大于cur为止
low += 1
num[low],num[high] = num[high],num[low] # 交互目前最大和最小位置
num[low] = cur
return low # 找到当前二分查找中间的位置下标
def findkth(num, low, high, k): # 找到数组里第k个数
index = partition(num, low, high)
if index == k: # 如果位置下标正好为k就已经找到
return num[index]
if index < k: # 如果k大于index说明要找的值在右面
return findkth(num, index + 1, high, k)
else: # 否则要找的k在左面
return findkth(num, low, index - 1, k)
l = [2, 3, 1, 5, 4, 6] # [1,2,3,4,5,6]
# pai = [2,2,2,2,2] # [1,2,3,4,5,6]
print findkth(l, 0, len(l) - 1, 3) # 第3号位置应该是：4
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def heap_build(parent, heap):
child = 2 * parent + 1
while child < len(heap):
if child + 1 < len(heap) and heap[child + 1] < heap[child]:
child = child + 1
if heap[parent] <= heap[child]:
break
heap[parent], heap[child] = heap[child], heap[parent]
parent, child = child, 2 * child + 1
return heap
def Find_heap_kth(array, k):
if k > len(array):
return None
heap = array[:k]
for i in range(k, -1, -1):
heap_build(i, heap)
for j in range(k, len(array)):
if array[j] > heap[0]:
heap[0] = array[j]
heap_build(0, heap)
return heap[0]
l = [2, 1, 4, 3, 5, 9, 8, 0, 1, 3, 2, 5]
print(Find_heap_kth(l, 6))
1.4 求丑数
1、丑数定义
1. 根据丑数的定义，丑数应该是另一个丑数乘以2、3或者5的结果（1除外）。
2. 因此我们可以创建一个数组，里面的数字是排好序的丑数。
3. 里面的每一个丑数是前面的丑数乘以2、3或者5得到的。
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def finduglynum(n):
uglynum = []
i = 1
count = 0
while True:
temp = i
while temp % 2 == 0:
temp = temp // 2
while temp % 3 == 0:
temp = temp // 3
while temp % 5 == 0:
temp = temp // 5
if temp == 1:
uglynum.append(i)
count += 1
if count >= n:
break
i += 1
return uglynum
# 测试
print finduglynum(8) # [1, 2, 3, 4, 5, 6, 8, 9]
#!usr/bin/env python
#encoding:utf-8
def finduglynum2(n):
uglynum = [1]
i = 1
t2 = m2 = 0
t3 = m3 = 0
t5 = m5 = 0
while i < n:
for x in range(t2, len(uglynum)):
m2 = uglynum[x] * 2
if m2 > uglynum[-1]:
t2 = x
# print("t2:",t2)
break
for x in range(t3, len(uglynum)):
m3 = uglynum[x] * 3
if m3 > uglynum[-1]:
t3 = x
break
for x in range(t5, len(uglynum)):
m5 = uglynum[x] * 5
if m5 > uglynum[-1]:
t5 = x
break
uglynum.append(min(m2, m3, m5))
i += 1
return uglynum
# 测试
print finduglynum2(10) # [1, 2, 3, 4, 5, 6, 8, 9, 10, 12]
这种思路的关键在于怎样确保数组里面的丑数是排好序的。 我们假设数组中已经有若干个丑数，排好序后存在数组中,我们把现有的最大丑数记做M。 现在我们来生成下一个丑数，该丑数肯定是前面某一个丑数乘以2、3或者5的结果。 我们首先考虑把已有的每个丑数乘以2。 在乘以2的时候，能得到若干个结果小于或等于M的。 由于我们是按照顺序生成的，小于或者等于M肯定已经在数组中了，我们不需再次考虑； 我们还会得到若干个大于M的结果，但我们只需要第一个大于M的结果，因为我们希望丑数是按从小到大顺序生成的，其他更大的结果我们以后再说。 我们把得到的第一个乘以2后大于M的结果，记为M2。 同样我们把已有的每一个丑数乘以3和5，能得到第一个大于M的结果M3和M5。 那么下一个丑数应该是M2、M3和M5三个数的最小者。 前面我们分析的时候，提到把已有的每个丑数分别都乘以2、3和5，事实上是不需要的，因为已有的丑数是按顺序存在数组中的。 对乘以2而言，肯定存在某一个丑数T2，排在它之前的每一个丑数乘以2得到的结果都会小于已有最大的丑数 在它之后的每一个丑数乘以2得到的结果都会太大。 我们只需要记下这个丑数的位置，同时每次生成新的丑数的时候，去更新这个T2。对乘以3和5而言，存在着同样的T3和T5。
1.5 最长递增子序列LIS的O(nlogn)的求法
1、说明
1. 最长递增子序列是指n个数的序列的最长单调递增子序列。
2. 比如，A = [1,3,6,7,9,4,10,5,6]的LIS是1 3 6 7 9 10。
2、实现一个复杂度O(nlogn)的算法
1. 如果 x 比所有的tails都大，说明x可以放在最长子序列的末尾形成一个新的自许下，那么就把他append一下，并且最长子序列长度增加1
2. 如果tails[i-1] < x <= tails[i]，说明x需要替换一下前面那个大于x的数字，以便保证tails是一个递增的序列，那么就更新tails[i]
3. 这样维护一个tails变量，最后的答案就是这个长度。
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def lengthOfLIS(nums):
tails = [0] * len(nums)
size = 0
for x in nums:
low = 0
high = size # size 0 1 2 3 3 统计当前列表最大单调长度
while low != high:
mid = (low + high) // 2 # 使用二分法找到x应该的位置
if tails[mid] < x: # x第一次为tials中间位置，如果x比较大，去tails后面的一半列表比较
# 直到找到tails中大于x元素的下标位置
low = mid + 1 # 使tails下标m加一（i加一后m就会加一）
else:
high = mid
tails[low] = x # 如果x比tails最后一个元素还大，就追加到tails末尾，否则替换嗲tials中第一个大于x的元素
size = max(low + 1, size)
return size
print lengthOfLIS([3, 4, 7, 2, 5]) # 3
比如我们的目标数组是[3, 4, 7, 2, 5]。 ####1. 第一步：x = 3 ''' 1）此时i = 0，直接令tails[0] = 3，tails = [3, 0, 0, 0, 0]。 2）说明到目前为止长度为1的递增子序列末尾最小为3。 ''' ####2. 第二步：x = 4 ''' 1)此时i != j，但是x大于tails的末尾，直接另tail[1] = 4， tails = [3, 4, 0, 0, 0]。 2)说明到目前为止长度为1的递增子序列末尾最小为3，长度为2的递增子序列末尾最小为4。 ''' ####3. 第三步：x = 7 ''' 1）大于tails的末尾，直接令tails[2] = 7，tails = [3, 4, 7, 0, 0]。 2）说明到目前为止长度为1的递增子序列末尾最小为3，长度为2的递增子序列末尾最小为4，长度为3的递增子序列末尾最小为7. ''' ####4. x = 2 ''' 1)此时x小于tails的末尾，需要用二分查找到比x大的最小的那个数更新之， 2)查找到tails中比2大的最小数是3，更新tail[0] = 2，此时tails = [2, 4, 7, 0, 0]。 3)说明到目前为止长度为1的递增子序列末尾最小为2，长度为2的递增子序列末尾最小为4，长度为3的递增子序列末尾最小为7。 ''' ####对第四步重点说明： ''' 1)这一步理解很关键，[2, 4, 7, 0, 0]的存在并不是说目前为止的递增子序列是2 4 7， 2)而是长度分别为1，2， 3的递增子序列目前所能得到的最小结尾元素是2，4，7。 3)我们这样做的目的就是，通过维护tails中的元素，保证每次对于长度为i+1的一个子序列对应的tails[i]元素最小， 4)“虽然在我之前，你们形成了一个长度为m的递增序列，但是呢，你们长度为m这个序列的末尾最大的一个数比我还大， 5)不如把我和末尾最大的那个元素换一下，这样你看咱们还是一个递增序列，长度也不变，但是我和你们更亲近”, 6)别的元素一听是这么个道理啊，于是就踢出最后一个元素，换上了这个新的更小的元素。 '''
tails的第i个位置记录nums中长度为i+1的所有递增子序列中，结尾最小的数字。 我们很容易证明，tails是一个递增的数组。 首先，tails[0]一定是所有元素中最小的那个数字min1，因为长度为1的子序列中，结尾最小的数字就是序列中最小的那个。 同样，长度为2的子序列中，结尾最小的的那个子序列的结尾元素一定大于min1， 因为首先所有长度为2的递增子序列，第二个元素一定比第一个元素大，如果长度为2的子序列中某个子序列的结尾元素小于min1， 那么在第一次操作中，这个元素就会更新为min1。 对于长度为3的子序列，假设之前tails已经存储了前两个结尾最小数[a, b]， 若长度为三的子序列结尾数字c3小于b，即[c1, c2, c3]是一个递增子序列，且c3 < b，则必然有c2 < b， 这样和之前的结论b是长度为2的递增子序列结尾最小元素矛盾。 所以，通过这样的一步步的反证法，很容易证明tails一定是一个递增的数组。 那么很容易通过二分查找， 找到在tails数组中需要被更新的那个数。
11111111
来源：https://www.cnblogs.com/xiaonq/p/10488342.html