算法面试题及答案

算法面试题及答案
一、数组与字符串
1.1 给定一个整数数组和一个目标值，找出数组中和为目标值的两个数，并返回它们的数组下标。

答案：
```python
def two_sum(nums, target):
hash_map = {}
for i, num in enumerate(nums):
complement = target - num
if complement in hash_map:
return [hash_map[complement], i]
hash_map[num] = i
return []
```
解释：使用哈希表存储数组中的每个元素及其下标。

遍历数组，计算当前元素与目标值的差值，并检查差值是否已经在哈希表中。

如果存在，返回当前元素的下标和差值对应的下标。

如果不存在，将当前元素及其下标加入哈希表。

1.2 如何判断一个字符串是否为另一个字符串的旋转？
答案：
```python
def is_rotation(s1, s2):
if len(s1) != len(s2):
return False
return s1 + s1 == s2
```
解释：首先检查两个字符串的长度是否相等，如果不相等则直接返回False。

然后将一个字符串与自身拼接，如果拼接后的字符串包含另一个字符串，则说明原字符串是另一个字符串的旋转。

二、链表问题
2.1 给定一个链表和一个特定值，删除链表中所有出现该值的节点。

答案：
```python
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def delete_elements(head, val):
d = ListNode(0)
d.next = head
prev = d
while prev.next:
if prev.next.val == val:
prev.next = prev.next.next
else:
prev = prev.next
return d.next
```
解释：创建一个哑节点（dummy node）作为链表的头节点，并用一个指针`prev`指向哑节点。

遍历链表，如果遇到值为`val`的节点，则删
除该节点，否则移动`prev`指针。

最后返回哑节点的下一个节点作为新链表的头。

2.2 合并两个有序链表。

答案：
```python
def merge_two_lists(l1, l2):
d = ListNode(0)
prev = d
while l1 and l2:
if l1.val < l2.val:
prev.next = l1
l1 = l1.next
else:
prev.next = l2
l2 = l2.next
prev = prev.next
if l1:
prev.next = l1
elif l2:
prev.next = l2
return d.next
```
解释：创建一个哑节点作为合并后链表的头节点。

使用两个指针分别遍历两个链表，比较节点的值，将较小的节点接在新链表后面，并移动对应链表的指针。

最后，如果其中一个链表遍历完毕，将另一个链表的剩余部分接到新链表后面。

三、树与递归
3.1 给定一棵二叉树和一个目标值，找出所有从根到叶子的路径上包含该目标值的路径。

答案：
```python
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def find_target_sum_paths(root, target):
def dfs(node, path, target):
if not node:
return []
path += str(node.val)
if not node.left and not node.right and sum(map(int, path)) == target:
return [path]
paths = []
if node.left:
paths.extend(dfs(node.left, path, target))
if node.right:
paths.extend(dfs(node.right, path, target))
return paths
return dfs(root, '', target)
```
解释：定义一个递归函数`dfs`，遍历二叉树的每个节点。

如果当前节点是叶子节点且路径上的值之和等于目标值，则将该路径添加到结果中。

否则，继续递归遍历左右子树。

3.2 给定一棵二叉搜索树，找到第k小的元素。

答案：
```python
def kth_smallest(root, k):
def inorder_traversal(node):
if not node:
return []
return inorder_traversal(node.left) + [node.val] + inorder_traversal(node.right)
inorder_list = inorder_traversal(root)
return inorder_list[k - 1]
```
解释：首先进行中序遍历，由于二叉搜索树的性质，中序遍历会按照升序访问所有节点。

然后返回遍历结果列表。