腾讯算法面试题补充

最新推荐文章于 2021-10-02 17:04:35 发布

jianafeng

最新推荐文章于 2021-10-02 17:04:35 发布

阅读量194

点赞数

分类专栏：算法题汇总专栏

本文链接：https://blog.csdn.net/Jiana_Feng/article/details/118631740

版权

算法题汇总专栏专栏收录该内容

16 篇文章 1 订阅

订阅专栏

目录标题

LT692:前K个高频单词

给一非空的单词列表，返回前 k 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序

方法一：堆排序

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        import heapq
        from collections import Counter
        count = Counter(words)
        #python维护的是最小堆。频数取反入队。先将所有数据的频数和它本身一起存到堆里
        #频数取反，这样每一次取到的都是最小值，也就是实际上的最大值。
        heap = [(-freq, word) for word, freq in count.items()]
        heapq.heapify(heap)
        return [heapq.heappop(heap)[1] for _ in range(k)]

剑指 Offer 29. 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

class Solution:
    def spiralOrder(self, matrix:[[int]]) -> [int]:
    	ans = []
    	#special case 
    	if not matrix: return []
    	#初始化
    	left,right,top,bottom = 0,len(matrix[0])-1,0,len(matrix)-1
    	while True: 
    		#从左到右打印
    		for i in range(left, right+1):
    			ans.append(matrix[top][i])
    		top+=1
    		if top > bottom: break 
			#从上到下打印
			for j in range(top,bottom+1):
				ans.append(matrix[j][right])
			right -= 1 
			if right < left: break 
			#从右到左打印
			for m in range(right,left-1,-1):
				ans.append(matrix[bottom][m])
			bottom -= 1 
			if top > bottom: break 
			#从下到上打印
			for n in range(bottom, top-1,-1):
				ans.append(matrix[n][left])
			left +=1 
			if right < left: break
		return ans

数据结构问题–堆

堆是一种什么样的数据结构,他每次进行操作的时间复杂度和空间复杂度
堆就是用数组实现的二叉树，所以它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。

堆分为两种：最大堆和最小堆，两者的差别在于节点的排序方式：
最大堆中，父节点的值比每一个子节点的值都要大。在最小堆中，父节点的值比每一个子节点的值都要小。这就是所谓的“堆属性”，并且这个属性对堆中的每一个节点都成立

堆和普通树的区别：
（1）二叉搜索树中，左子节点必须比父节点小，右子节点必须必比父节点大。但是在堆中并非如此。在最大堆中两个子节点都必须比父节点小，而在最小堆中，它们都必须比父节点大。
（2）平衡。二叉搜索树必须是“平衡”的情况下，其大部分操作的复杂度才能达到O(log n)。你可以按任意顺序位置插入/删除数据，或者使用 AVL 树或者红黑树，但是在堆中实际上不需要整棵树都是有序的。我们只需要满足堆属性即可，所以在堆中平衡不是问题。因为堆中数据的组织方式可以保证O(log n) 的性能。

说说快速排序时间复杂度，何时o(n2)，有什么方法可以优化快速排序？？

如何用rand7() 去实现rand10()

分析
首先
rand7()出来的是 1，2，3，4，5，6，7
所以让(rand7() -1) 得到的可能数有 0，1，2，3，4，5，6
✖️ 7 得到可能的数是 0，7，14，21，28，35，42
这个时候再加上 rand7（）
则有可能的数是
首先0 + rand7（）有
1，2，3，4，5，6，7
然后7 + rand7（）有
8，9，10，11，12，13，14
然后14 + rand7（）有
15，16，17，18，19，20，21
然后21 + rand7（）有
22，23，24，25，26，27，28
然后28 + rand7（）有
29，30，31，32，33，34，35
然后35 + rand7（）有
36，37，38，39，40，41，42
然后42 + rand7（）有
43，44，45，46，47，48，49
所以可能的数 1-49 有49个数。

我们可以通过（x - 1) % 10 + 1 来均等的生成1到10 的整数其中x是1-40

class Solution:
    def rand10(self):
        """
        :rtype: int
        """
        idx = 49
        while idx > 40:
            row = rand7()
            col = rand7()
            idx = row + (col - 1) * 7
            if idx <= 40:
                return 1 + (idx - 1) % 10

面试题 01.05. 一次编辑

面试题 01.05. 一次编辑
字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑

输入: 
first = "pale"
second = "ple"
输出: True
输入: 
first = "pales"
second = "pal"
输出: False

class Solution:
    def oneEditAway(self, first: str, second: str) -> bool:
        #create dp
        row= len(first)
        col = len(second)
        dp=[[0]*(col+1) for _ in range(row+1)]
        for i in range(row):
            dp[i+1][0]=i+1
        for j in range(col):
            dp[0][j+1]=j+1

        for i in range(row):
            for j in range(col):
                if first[i] == second[j]:
                    p =dp[i][j]
                else:
                    p=dp[i][j]+1
                dp[i+1][j+1] = min(p,dp[i][j+1]+1, dp[i+1][j]+1)
        return dp[row][col]<=1

一个十进制数有多少种给定二进制表示方法

Python中常用的内置进制转换函数如下所示：
bin(x): 将 x 转换为2进制
如果是比较小的数比如
37 找到跟37最近的2的某平方是 32
然后找5最相近的2的某平方是4
直到只剩下1或者0
所以用一个递归函数计算最近的

def log2(x):
	if x==1:return 0
	else:
		return 1+log2(x)

1、判断是不是2的幂
将2的幂写成二进制很容易看出，2的幂的二进制只有一个1，其余全是0，如下所示：
000010000…00
而将2的幂的二进制减1，其二进制变为：
000001111…11
所以判断一个数是不是2的幂的方法为使用按位与操作，如果结果为0，则是2的幂：
n & (n-1)

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是是它自己的祖先

其中一个比较重要的思路是

从树根开始，如果当前节点值大于p和q，那么p和q的公共祖先，一定在当前节点的左子树上。
从树根开始，如果当前节点值小于p和q，那么p和q的公共祖先，一定在当前节点的右子树上。
从树根开始，如果当前节点值介于p和q，那么该节点就是p和q的最近公共节点

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        #确保p的值是最小的 q最大
        if p.val > q.val:
            p,q = q,p
        while True:
            if root.val < p.val:
                root=root.right 
            elif root.val > q.val:
                root = root.left
            else:
                return root

如果不是二叉搜索树而是普通的树呢？

class Solution:
    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
        if not root or root == p or root == q:
            return root 
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)

        if not left: return right 
        if not right: return left 
        return root

如果p和q分别在节点的两边，那么该节点就是最近的公共祖先
p和q都在该节点的左子树，那么继续找该节点的左子树
p和q都在该节点的右子树，那么继续找该节点的右子树

如果root为空，那么返回root，若root=p 或者 root=q 那么已经找到，就是root
如果上面两种情况都没有，那么就要继续分别在root的左右子树寻找，如果找到该节点的最左子树（left=None），依旧没有找到，那么说明，p和q在右子树上（返回右子树的情况）

如果上面两种情况都没有，那么就要继续分别在root的左右子树寻找，如果找到root的最右子树（left=None），依旧没有找到，那么说明，p和q在左子树上（返回左子树的情况）。

662. 二叉树最大宽度

二叉树最大宽度

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def widthOfBinaryTree(self, root: TreeNode) -> int:
        if not root: return 0
        queue = [(root,1)]
        width = 0
        while queue:
            size = len(queue)
            for i in range(size):
                node, nums = queue.pop(0)
                if i ==0:
                    bgn = nums
                if i == size-1:
                    end = nums
                    width = max(width, end-bgn+1)
                if node.left: queue.append((node.left, 2*nums))
                if node.right:queue.append((node.right, 2*nums+1))
        return width

说说快速排序时间复杂度，何时o(n2)，有什么方法可以优化快速排序

当数组是有序的或者是倒叙的时候，
当每次找的基准都是最小值或者最大值，导致每次只改变一个位置，相当for loop两次。
导致时间复杂度O(n^2)

基本的快速排序选取第一个或最后一个元素作为基准。但是，这是一直很不好的处理方法.
如果数组已经有序时，此时的分割就是一个非常不好的分割。因为每次划分只能使待排序序列减一，此时为最坏情况.

于是优化情况是
（1）随机选取基准。
引入的原因：在待排序列是部分有序时，固定选取枢轴使快排效率底下，要缓解这种情况，就引入了随机选取枢轴。
取待排序列中任意一个元素作为基准

（2）三数取中（median-of-three）
一般的做法是使用左端、右端和中心位置上的三个元素的中值作为枢纽元。

举例：待排序序列为：8 1 4 9 6 3 5 2 7 0

左边为：8，右边为0，中间为6.

我们这里取三个数排序后，中间那个数作为枢轴，则枢轴为6
显然使用三数中值分割法消除了预排序输入的不好情形，并且减少快排大约14%的比较次数

jianafeng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
腾讯算法面试题补充

目录标题LT692:前K个高频单词剑指 Offer 29. 顺时针打印矩阵数据结构问题--堆LT692:前K个高频单词给一非空的单词列表，返回前 k 个出现次数最多的单词。返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序方法一：堆排序class Solution: def topKFrequent(self, words: List[str], k: int) -> List[str]: import heapq
复制链接

扫一扫