算法面试其他篇
目录：
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