算法面试其他篇
目录:
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]
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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、合并两个有序列表
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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]
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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]
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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、一个有序列表找中位数
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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和他本身没有其他的约数)
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#!/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]
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#!/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取余即可 '''
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))。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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
注:这种方法如果又重复元素很容易导致死循环
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#!/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
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#!/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得到的。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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]
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#!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]
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
这种思路的关键在于怎样确保数组里面的丑数是排好序的。
我们假设数组中已经有若干个丑数,排好序后存在数组中,我们把现有的最大丑数记做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变量,最后的答案就是这个长度。
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
#! /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
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
比如我们的目标数组是[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)别的元素一听是这么个道理啊,于是就踢出最后一个元素,换上了这个新的更小的元素。 '''
![](https://i-blog.csdnimg.cn/blog_migrate/8f900a89c6347c561fdf2122f13be562.gif)
![](https://i-blog.csdnimg.cn/blog_migrate/961ddebeb323a10fe0623af514929fc1.gif)
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