算法面试必备-----手撕代码高频题_算法岗面试手撕代码

算法面试必备-----手撕代码高频题

贝壳

无序数组中找出和为N的两个数（三个数、四个数）

参考

编辑距离

给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

1、插入一个字符
2、删除一个字符
3、替换一个字符
示例1

输入: word1 = “horse”, word2 = “ros”
输出: 3
解释:
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)

示例2

输入: word1 = “intention”, word2 = “execution”
输出: 5
解释:
intention -> inention (删除 ‘t’)
inention -> enention (将 ‘i’ 替换为 ‘e’)
enention -> exention (将 ‘n’ 替换为 ‘x’)
exention -> exection (将 ‘n’ 替换为 ‘c’)
exection -> execution (插入 ‘u’)

解题思路
dp[i][j] 表示 word1 的前 i 个字母和 word2 的前 j 个字母之间的编辑距离

如果word1[i] = word2[j]，即两个子串的最后一个字母相同，就不用操作：
dp[i][j] = dp[i-1][j-1]

否则，在插入，替换和删除之中选择当前总编辑距离最小的一个，即

在dp[i][j-1]的基础上，在word1后插入一个和word2[j]一样的字符
在dp[i-1][j]的基础上，删除word1的第i个字符
在dp[i-1][j-1]的基础上，替换word1的最后一个字符和word2[j]相同
dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1

class Solution(object):
    def minDistance(self, word1, word2):
        """
        :type word1: str
        :type word2: str
        :rtype: int
        """
        n = len(word1)+1
        m = len(word2)+1
        dp = [[0]*m for _ in range(n)]
        for i in range(n):
            for j in range(m):
                if j==0 or i==0:
                    dp[i][j] = max(j, i)
                elif word1[i-1]==word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min([dp[i-1][j],dp[i][j-1],dp[i-1][j-1]])+1
        
        return dp[n-1][m-1]
        
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

字节跳动

阶乘末尾0的个数

输入描述:
输入为一行，n(1 ≤ n ≤ 1000)
输出描述:
输出一个整数,即题目所求
解法：要判断末尾有几个0就是判断可以整除几次10。10的因子有5和2，而在0~9之间5的倍数只有一个，2的倍数相对较多，所以本题也就转换成了求N阶乘中有几个5的倍数。
也就是每多出来一个5，阶乘末尾就会多出来一个0，这样n / 5就能统计完第一层5的个数，依次

class Solution(object):
	def calcuZero(object,n):
		count = 0
		for i in range(1,n+1):
			cur = i
			while(cur % 5 == 0):
				count  += 1
				cur /= 5
		return count
1
2
3
4
5
6
7
8
9

判断一颗二叉树是否为镜像对称

解法：判断一个数是否为镜像对称：先判断根，在判断左右子树。如果左右子树都为空那就是，如果左右子树不是同时为空那就不是

当左右子树都存在的时候，判断他们的值是否相等,如果相等那么久递归的对他们的字节点判断（左边的左=右边的右；左边的右==右边的左）

class Solution(object):
	
class Solution(object):
    def isSymmetric(self, root):
        if root == None:
            return True
        return self.recurse(root.left, root.right)

    def recurse(self, leftNode, rightNode):
        if leftNode == None and rightNode == None:
            return True
        elif leftNode != None and rightNode != None:
            if leftNode.val == rightNode.val:
                return self.recurse(leftNode.left, rightNode.right) and self.recurse(leftNode.right, rightNode.left)
            else:
                return False
        else:
            return False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

求一个无序数组的中位数

用sort()

class Solution(object):
    def get_mid(self,arr):
        if arr == []:
            return None
        arr.sort()
        print(arr)
        length = len(arr)

        if length%2==0:
            print(length)
            return arr[int(length/2)-1],arr[int(length/2)]
        elif length%2 != 0:
            return arr[length//2]
1
2
3
4
5
6
7
8
9
10
11
12
13

用快排的方法

在这里插入代码片
1

有序的数组中找到某一目标值首次出现的下标

class Solution(object):
	def find_search(self,arr,length,target):
		left = 0
		right = length-1
		if (arr[right-1] < target and length < 0 and arr == None):
			return -1
		while left < right:
			mid = (left+right)//2
			if arr[mid] < target:
				left = mid + 1
			else:
				right = mid
		if arr[left] == target:
			return left
		else:
			return -1




if __name__ == "__main__":
    arr = [4,6,6,6,6]
    solu = Solution()
    print(solu.find_search(arr,5,6))


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

给两个链表，每个节点存储一个数字，实现两个节点之间的数字相加，返回相加后的数字链表

在这里插入代码片
1

给定数组，从数组中取出n个不复用的数的和为sum

猿辅导

求两个超长数字字符串的和（直接相加会发生溢出）

‘123…0’
‘333…9’
1、题目
实现两个百位长的数字直接相加。
2、分析
两个超长的数字无法直接进行加法操作，需进行相应转化才能实现结果输出。参照加法原理，将两数字对齐，而后从个位至高位，每个数字依次相加，同时考虑进位情况，最后将结果输出。
3、实现
考虑到两数字之间位数不同问题，需将两数字进行对齐。

	char *num1 = "989898989898989898989";
	char *num2 = "91325645689798798798798789";
	int length1 = strlen(num1);
	int length2 = strlen(num2);
	int i,j,k = 0;
	char res[128]  = {0};
	int idx = 0;
	int benwei = 0 ,jinwei = 0;		// 每位计算结果的本位与进位
	int max_length = length1 > length2 ? length1:length2;	
	int num1_offset = max_length - length1;		//按个位对齐时偏移
	int num2_offset = max_length - length2;
	
	for(i = max_length - 1; i >= 0; i--){
		j = i - num1_offset >= 0 ? num1[i - num1_offset] - '0' : 0;       // 转数字
		k = i - num2_offset >= 0 ? num2[i - num2_offset] - '0' : 0;
		benwei = (j + k + jinwei) % 10;
		jinwei = (j + k + jinwei) / 10;
		res[idx++] = benwei + '0';		
	}

	if(jinwei)
		res[idx] = jinwei + '0';
	
	int len_res = strlen(res);
	while(len_res--)
		printf("%c",res[len_res]);
	printf("\n");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出结果：
91326635588788697788697778
与计算器校验结果一致。

最长公共子序列（可以非连续）

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

示例 1:

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace"，它的长度为 3。
1
2
3

示例 2:

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc"，它的长度为 3。
1
2
3

示例 3:

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0。
1
2
3

提示:

1 <= text1.length <= 1000
1 <= text2.length <= 1000
输入的字符串只含有小写英文字符。

class Solution(object):
    def longestCommonSubsequence(self, text1, text2):
        """
        :type text1: str
        :type text2: str
        :rtype: int
        """
        if text1 == None or text2 == None:
        	return 0
        m = len(text1)
        n = len(text2)
        dp = [[0]*(n+1) for _ in range(m+1)]
        for i in range(1,m+1):
        	for j in range(1,n+1):
        		if text1[i-1] == text2[j-1]:
        			dp[i][j] = dp[i-1][j-1]+1
        		else:
        			dp[i][j] = max(dp[i-1][j],dp[i][j-1])
        return dp[m][n]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

最长连续公共子序列

class Solution(object):
	def LCS(self,text1,text2):
		if text1 == None or text2 == None:
			return 0
		m = len(text1)
		n = len(text2)
		dp = [[0]*(n+1) for _ in range(m+1)]
		for i in range(1,m+1):
			for j in range(1,n+1):
				if text1[i-1] == text2[j-1]:
					dp[i][j] = dp[i-1][j-1] + 1
				else:
					dp[i][j] = 0
if __name__ == "__main__":
	solu = Solution()
	t1 = raw_input()
	t2 = raw_input()
	print(solu.LCS(t1,t2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

最长递增数组（可以非连续）

class Solution(object):
    def longest_rising_subarray(self,arr):
        dp = [1 for _ in range(len(arr))]
        for i in range(1, len(arr)):
            for j in range(i):
                if arr[j] < arr[i] and dp[j] + 1 > dp[i]:
                    dp[i] = dp[j] + 1
        return dp[-1]

if __name__ == "__main__":
    solu = Solution()
    print(solu.longest_rising_subarray([1,3,5,4,7,8,9]))
1
2
3
4
5
6
7
8
9
10
11
12

最长连续递增数组

给定一个未经排序的整数数组，找到最长且连续的的递增序列，并返回该序列的长度。

示例 1:

输入: [1,3,5,4,7]
输出: 3
1
2

解释: 最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为5和7在原数组里被4隔开。
示例 2:

输入: [2,2,2,2,2]
输出: 1
1
2

解释: 最长连续递增序列是 [2], 长度为1。

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if nums == []:
            return 0
        m  = len(nums)
        dp = [0]*(m+1)
        for i in range(0,m):
            if nums[i] > nums[i-1]:
                dp[i] = dp[i-1]+1
            else:
                dp[i] = 1
        return max(dp)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

最长回文子串长度

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: int
        """
        d = {}
        length = 0
        k = 0
        for i in s:
            if i not in d:
                d[i] = 1
            else:
                d[i] += 1
        for value in d.values():
            if value % 2 == 0:
                length += value
            else:
                length += value-1#当为单数时，可去掉一个变为双数
                k = 1#单数只能出现一次
        return length + k
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

求两个字符串的最大公共子串

在这里插入代码片
1

零钱兑换

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3 
1
2

解释: 11 = 5 + 5 + 1
示例 2:

输入: coins = [2], amount = 3
输出: -1
1
2

动态规划。用dp[i] 表示组成 i 元所需要的最小硬币数。

显然对于coins数组里的所有元素j，所有的dp[j] = 1。

以样例输入一为例：

对于其他的dp[i] = 1 + min(dp[i - 1], dp[i - 2], dp[i - 5])

即求11元的答案可以转化为： 1个一元硬币 + 10元答案 或者 1个两元硬币 + 9元答案 或者1个五元硬币 + 6元答案。

所以dp[i] = 1 + min(dp[i - j]) for j in coins

class Solution(object):
    def coinChange(self, coins, amount):
        """
        :type coins: List[int]
        :type amount: int
        :rtype: int
        """
        if amount == 0:
            return 0
        dp = []
        max_int = 2<<31
        
        for i in range(amount+1):
            if i not in coins:
                dp.append(max_int)
            else:
                dp.append(1)
        
        for i in range(amount+1):
            if i not in coins:
                for j in coins:
                    if i -j > 0:
                        dp[i] = min(dp[i-j]+1,dp[i])
        return dp[amount] if dp[amount] != max_int else -1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

零钱兑换 II

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

示例 1:

输入: amount = 5, coins = [1, 2, 5]
输出: 4
1
2

解释: 有四种方式可以凑成总金额:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
示例 2:

输入: amount = 3, coins = [2]
输出: 0
1
2

解释: 只用面额2的硬币不能凑成总金额3。
示例 3:

输入: amount = 10, coins = [10] 
输出: 1
1
2

class Solution(object):
    def change(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        n = len(coins)
        dp = [0]*(amount+1)
        dp[0] = 1
        for i in range(n):
            for j in range(1,amount+1):
                if j >= coins[i]:
                    dp[j] = dp[j]+dp[j-coins[i]]
        return dp[amount]
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

以X为基准分割链表

以给定X为基准将链表分割为两部分，所有小于X的节点排在大于等于节点之前，并且保持原来顺序基本不变。

输入: head = 1->4->3->2->5->2, x = 3
输出: 1->2->2->4->3->5
1
2

根据题目可知，最后的链表中所有小于 x 的节点都在大于或等于 x 的节点之前，而且必须保留元素之间的相对关系。例如对于1->4->3->2->5->2来说，分隔的变化过程为：[1] -> [1,4] -> [1,4,3] -> [1,2,4,3] -> [1,2,2,4,3] -> [1,2,2,4,3,5]。

最终链表可以看作是在保留相关位置关系的基础上的两个链表的链接，其中一个是大于或等于x的元素组成的链表，另一个是小于x的元素组成的链表。因此，一种很自然的想法就是：我们可以新建两个链表beforeHead和afterHead分别存放两部分的元素，最后将afterHead链接到beforeHead后面即可。

class ListNode(object):
    def __init__(self,x):
        self.val = x
        self.next = None
class Solution(object):
    def partition(self,head,x):
        #双链表法
        beforeHead = ListNode(0)
        afterHead = ListNode(0)

        a,b = afterHead,beforeHead
        while head:
            if head.val >= x:
                a.next = head
                a = a.next
            else:
                b.next = head
                b = b.next

            head = head.next
        a.next = None
        b.next = afterHead.next

        return beforeHead.next


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

二叉树的所有路径

class TreeNode(object):
    def __init__(self,x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        if not root:
            return []
        res = []
        stack = [(root,"")]
        while stack:
            node,ls = stack.pop()
            if not node.left and not node.right:
                res.append(ls+str(node.val))
                
            if node.left:
                stack.append((node.left, ls + str(node.val) + "->"))
            if node.right:
                stack.append((node.right,ls+str(node.val)+"->"))
        return res
                
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

二叉树中的最大路径和

给定一个非空二叉树，返回其最大路径和。

本题中，路径被定义为一条从树中任意节点出发，达到任意节点的序列。该路径至少包含一个节点，且不一定经过根节点。

示例 1:

输入: [1,2,3]

   1
  / \
 2   3
1
2
3

输出: 6
1
2
3
4
5
6
7
示例 2:

输入: [-10,9,20,null,null,15,7]

	 -10
	  / \
     9  20
    / \
   15  7
1
2
3
4
5

输出: 42

class Solution:
    def maxPathSum(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        res = float('-inf')
        def maxPath(node):
            nonlocal res 
            if not node:
                return 0
            
            left = max(0, maxPath(node.left))
            right = max(0, maxPath(node.right))
            res = max(res, left + right + node.val)
            return max(left, right) + node.val
        
        maxPath(root)
        return res

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20