由于本人的主力语言为python，以下面试题都用python实现
面试题之二：实现Singleton模式
题目：实现一个单例模式
class Singleton(object):
_instance = None
_instance_lock = threading.Lock()
def __init__(self, *args, **kwargs):
pass
def __new__(cls, *args, **kwargs):
if cls._instance:
return cls._instance
with cls._instance_lock:
cls._instance = object.__new__(cls)
return cls._instance
面试题之三：二维数组中的查找
题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数
例如下面的数组，如果查找数字7，则返回True；如果查找数字5，则返回False
[
[1,2,8,9],
[2,4,9,12],
[4,7,10,13],
[6,8,11,15]
]
思路：
1.从左下角开始选取元素，将此元素与目标元素比较，有三种可能的情况
1）此元素与目标元素相等，返回True，程序结束
2）此元素小于目标元素，则在这个元素的右侧开始查找
3）此元素大于目标元素，则在这个元素的上侧开始查找
2.重复步骤1，直到结束，返回False
代码
def find_in_partially_sorted_matrix(matrix, num):
'''
:type matrix: List[List[int]]
:type num: int
:rtype: bool
'''
if not matrix or not matrix[0]:
return False
if num < matrix[0][0] or num > matrix[-1][-1]:
return False
i, j = len(matrix) - 1, 0
while i >= 0 and j <= len(matrix[0]) - 1:
if matrix[i][j] == num:
return True
elif matrix[i][j] < num:
j += 1
elif matrix[i][j] > num:
i -= 1
return False
if __name__ == '__main__':
matrix = [
[1, 2, 8, 9],
[2, 4, 9, 12],
[4, 7, 10, 13],
[6, 8, 11, 15]
]
#print(find_in_partially_sorted_matrix(matrix, 10))
#print(find_in_partially_sorted_matrix(matrix, 4))
#print(find_in_partially_sorted_matrix(matrix, 15))
#print(find_in_partially_sorted_matrix(matrix, 9))
#print(find_in_partially_sorted_matrix(matrix, 5))
#print(find_in_partially_sorted_matrix(matrix, -1))
#print(find_in_partially_sorted_matrix(matrix, 1))
#print(find_in_partially_sorted_matrix(matrix, 18))
matrix = [
[-2, 1, 5, 9]
]
#print(find_in_partially_sorted_matrix(matrix, -2))
#print(find_in_partially_sorted_matrix(matrix, 5))
#print(find_in_partially_sorted_matrix(matrix, 9))
#print(find_in_partially_sorted_matrix(matrix, -1))
#print(find_in_partially_sorted_matrix(matrix, -3))
#print(find_in_partially_sorted_matrix(matrix, 10))
matrix = [
[-5,],
[-2,],
[3,],
[6,],
[8,]
]
#print(find_in_partially_sorted_matrix(matrix, 0))
#print(find_in_partially_sorted_matrix(matrix, -8))
#print(find_in_partially_sorted_matrix(matrix, 6))
#print(find_in_partially_sorted_matrix(matrix, 8))
#print(find_in_partially_sorted_matrix(matrix, -5))
#print(find_in_partially_sorted_matrix(matrix, 10))
matrix = []
#print(find_in_partially_sorted_matrix(matrix, 3))
matrix = [
[],
[],
[]
]
print(find_in_partially_sorted_matrix(matrix, 5))
面试题之五：从尾到头打印链表
class ListNode(object):
def __init__(self, val):
self.val = val
self.next = None
def print_list_node_reversingly(head: ListNode) -> None:
stack = []
p = head
while p is not None:
stack.append(p.val)
p = p.next
while len(stack) != 0:
print(stack.pop())
if __name__ == '__main__':
p1 = ListNode(1)
p2 = ListNode(2)
p3 = ListNode(3)
p4 = ListNode(4)
p1.next = p2
p2.next = p3
p3.next = p4
print_list_node_reversingly(p1)
p1 = ListNode(1)
print_list_node_reversingly(p1)
p = None
print_list_node_reversingly(p)
面试题之六：重建二叉树
题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树，输出二叉树的头结点
from typing import List
class TreeNode(object):
def __init__(self, val):
self.val = val
self.left = None
self.right = None
def construct_binary_tree(preorder: List[int], inorder: List[int]) -> TreeNode:
"""重建二叉树"""
if len(preorder) == 0:
return None
if len(preorder) == 1:
root = TreeNode(preorder[0])
return root
index = inorder.index(preorder[0])
left_child_preorder = preorder[1:index + 1]
right_child_preorder = preorder[index + 1:]
left_child_inorder = inorder[:index]
right_child_inorder = inorder[index + 1:]
root = TreeNode(preorder[0])
root.left = construct_binary_tree(left_child_preorder, left_child_inorder)
root.right = construct_binary_tree(right_child_preorder, right_child_inorder)
return root
def level_order_travel(root: TreeNode) -> List:
"""输出宽度优先遍历的结果，用于验证"""
levels = []
if not root:
return levels
def helper(node: TreeNode, level: int) -> None:
if len(levels) == level:
levels.append([])
levels[level].append(node.val)
if node.left:
helper(node.left, level + 1)
if node.right:
helper(node.right, level + 1)
helper(root, 0)
return levels
if __name__ == '__main__':
preorder = [3, 9, 20, 15, 7]
inorder = [9, 3, 15, 20, 7]
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
preorder = [1, 2, 4, 8, 9, 14, 5, 10, 11, 3, 6, 12, 13, 7]
inorder = [8, 4, 14, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 7]
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
preorder = [1, 2, 3]
inorder = [1, 3, 2]
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
preorder = [1, 2, 3]
inorder = [3, 2, 1]
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
preorder = [1, 2, 3]
inorder = [1, 2, 3]
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
preorder = [2]
inorder = [2]
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
preorder = []
inorder = []
root = construct_binary_tree(preorder, inorder)
print(level_order_travel(root))
面试题之七：用两个栈实现队列
题目：用两个栈实现队列，分别完成在尾部插入结点和在队列头部删除结点的功能
class Stack(object):
def __init__(self):
self.stack = []
def push(self, item):
self.stack.append(item)
def pop(self):
if not self.stack:
return "empty stack!"
return self.stack.pop()
def is_empty(self):
return len(self.stack) == 0
class MyQueue(object):
def __init__(self):
self.stack1 = Stack()
self.stack2 = Stack()
def append_tail(self, item):
self.stack1.push(item)
def delete_head(self):
if not self.stack2.is_empty():
return self.stack2.pop()
if self.stack1.is_empty():
return "empty queue!"
while not self.stack1.is_empty():
self.stack2.push(self.stack1.pop())
return self.stack2.pop()
if __name__ == "__main__":
q1 = MyQueue()
q1.append_tail(1)
q1.append_tail(2)
q1.append_tail(3)
print(q1.delete_head())
print(q1.delete_head())
print(q1.delete_head())
print(q1.delete_head())
print("-------------------")
q2 = MyQueue()
q2.append_tail(1)
print(q2.delete_head())
print(q2.delete_head())
q2.append_tail(2)
q2.append_tail(3)
print(q2.delete_head())
补充：用两个队列实现栈
题目：用两个队列实现栈，分别完成压入和弹出功能
from queue import Queue
class Stack(object):
def __init__(self):
self.queue1 = Queue()
self.queue2 = Queue()
def push(self, item):
if self.queue1.empty():
self.queue2.put(item)
else:
self.queue1.put(item)
def pop(self):
if self.queue1.empty() and self.queue2.empty():
return "empty stack!"
if self.queue1.empty():
while not self.queue2.empty():
item = self.queue2.get()
if self.queue2.empty():
return item
self.queue1.put(item)
else:
while not self.queue1.empty():
item = self.queue1.get()
if self.queue1.empty():
return item
self.queue2.put(item)
if __name__ == "__main__":
s1 = Stack()
s1.push(1)
s1.push(2)
print(s1.pop())
print(s1.pop())
print(s1.pop())
print("--------------")
s2 = Stack()
print(s2.pop())
s2.push(1)
s2.push(2)
print(s2.pop())
s2.push(3)
print(s2.pop())
print(s2.pop())
print(s2.pop())
持续更新中...