增加剑指offer python 题解

Author: PegasusWang

剑指offer/03_FindInPartiallySortedMatrix(二维数组中的查找).py

@@ -0,0 +1,48 @@
+"""
+剑指offer 第三题。从左到右升序从上到下升序数组，判断是否能找到一个值
+思路：
+从右上角开始找，大于 target 排除当前列。小于 target 排除当前行
+"""
+
+
+class Solution:
+    def solve(self, matrix, target):
+        if not matrix or not matrix[0]:
+            return False
+        leny = len(matrix)
+
+        x = 0
+        y = leny - 1
+
+        while x >= 0 and y >= 0:
+            if matrix[x][y] == target:
+                return True
+            elif matrix[x][y] > target:
+                y -= 1
+            else:
+                x += 1
+        return False
+
+
+def test():
+    s = Solution()
+    matrix = [
+        [1, 2, 8, 9],
+        [2, 4, 9, 12],
+        [4, 7, 10, 13],
+        [6, 8, 11, 15],
+    ]
+    assert s.solve(matrix, 0) is False
+    assert s.solve(matrix, 1) is True
+    assert s.solve(matrix, 7) is True
+    assert s.solve(matrix, 5) is False
+
+    # empty
+    matrix = [
+        [],
+    ]
+    assert s.solve(matrix, 0) is False
+
+
+if __name__ == '__main__':
+    test()

剑指offer/04_ReplaceBlank(替换空格).py

@@ -0,0 +1,36 @@
+"""
+替换字符串中的空格
+题目：请实现一个函数，把字符串中的每个空格替换成"%20"。例如输入“We are happy.”，则输出“We%20are%20happy.”
+"""
+
+
+class Solution:
+    def solve(self, string):
+        """因为 python string 不可变对象，和其他的语言用字符串数组能直接修改有点区别"""
+        res = []
+        for char in string:
+            if char == ' ':
+                res.append('%20')
+            else:
+                res.append(char)
+        return ''.join(res)
+
+    def solve2(self, string):
+        """
+        思路：
+        先遍历一次计算替换后的总长度
+        从后往前替换，防止从前往后需要
+        """
+        pass
+
+
+def test():
+    s = Solution()
+    ss = 'We are happy.'
+    assert s.solve(ss) == 'We%20are%20happy.'
+
+    assert s.solve('') == ''
+
+
+if __name__ == '__main__':
+    test()

剑指offer/05_PrintListInReversedOrder(从尾到头打印链表).py

@@ -0,0 +1,59 @@
+"""
+面试题5：从尾到头打印链表
+题目：输入一个链表的头结点，从尾到头反过来打印出每个结点的值。链表结点定义如下：
+"""
+from collections import deque
+
+
+class Stack:
+    def __init__(self):
+        self.items = deque()
+
+    def push(self, val):
+        return self.items.append(val)
+
+    def pop(self):
+        return self.items.pop()
+
+    def empty(self):
+        return len(self.items) == 0
+
+
+class Node:
+    def __init__(self, val, next=None):
+        self.val, self.next = val, next
+
+
+class Solution:
+    def solve(self, headnode):
+        """
+        思路：用一个栈保存所有节点，之后一个一个 pop
+        """
+        val_s = Stack()
+        cur_node = headnode
+        while cur_node:
+            val_s.push(cur_node.val)
+            cur_node = cur_node.next
+        while not val_s.empty():
+            print(val_s.pop())
+
+    def solve2(self, headnode):
+        """
+        能用栈就可以使用递归。这一点需要能联想到
+        """
+        curnode = headnode
+        if curnode:
+            self.solve2(curnode.next)
+            print(curnode.val)   # 注意 print 放到 递归之后才是倒序
+
+
+def test():
+    s = Solution()
+    linklist = Node(0, Node(1))
+    s.solve2(linklist)
+
+    # linklist = Node(0)
+    # s.solve2(linklist)
+
+if __name__ == '__main__':
+    test()

剑指offer/06_ConstructBinaryTree(重建二叉树).py

@@ -0,0 +1,63 @@
+"""
+面试题6：重建二叉树
+题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
+例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出图2.6所示的二叉树并输出它的头结点。二叉树结点的定义如下：<Paste>
+"""
+
+
+class Node:
+    def __init__(self, val, left=None, right=None):
+        self.val, self.left, self.right = val, left, right
+
+
+class Solution:
+    def __init__(self):
+        self.pres = []
+        self.inorders = []
+
+    def solve(self, prevals, invals):
+        """
+        思路：先序找到根，然后可以找到中序遍历根的位置确定左子树和右子树，递归处理
+        """
+        if not prevals or not invals:
+            return None
+        root_val = prevals[0]
+        root = Node(root_val)
+        inorder_root_idx = invals.index(root_val)
+        left_length = inorder_root_idx
+        right_length = len(invals) - inorder_root_idx - 1
+
+        if left_length:
+            root.left = self.solve(prevals[1:1 + left_length], invals[:inorder_root_idx])
+
+        if right_length:
+            root.right = self.solve(prevals[left_length + 1:], invals[inorder_root_idx + 1:])
+        return root
+
+    def inorder(self, subtree):
+        if subtree:
+            self.inorder(subtree.left)
+            self.inorders.append(subtree.val)
+            self.inorder(subtree.right)
+
+    def preorder(self, subtree):
+        if subtree:
+            self.pres.append(subtree.val)
+            self.preorder(subtree.left)
+            self.preorder(subtree.right)
+
+
+def test():
+    s = Solution()
+    prevals = [1, 2, 4, 7, 3, 5, 6, 8]
+    invals = [4, 7, 2, 1, 5, 3, 8, 6]
+    root = s.solve(prevals, invals)
+    s.inorder(root)
+    assert s.inorders == invals
+
+    s.preorder(root)
+    assert s.pres == prevals
+
+
+if __name__ == '__main__':
+    test()

剑指offer/07_QueueWithTwoStacks(用两个栈实现队列).py

@@ -0,0 +1,56 @@
+"""
+面试题7：用两个栈实现队列
+题目：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deleteHead，分别完成在队列尾部插入结点和在队列头部删除结点的功能。
+"""
+
+from collections import deque
+
+
+class Stack:
+    def __init__(self):
+        self.items = deque()
+
+    def push(self, val):
+        return self.items.append(val)
+
+    def pop(self):
+        return self.items.pop()
+
+    def empty(self):
+        return len(self.items) == 0
+
+    def __len__(self):
+        return len(self.items)
+
+
+class Queue:
+    def __init__(self):
+        self.s1 = Stack()
+        self.s2 = Stack()
+
+    def append(self, val):
+        self.s1.push(val)
+
+    def pop(self):
+        if len(self.s2):
+            return self.s2.pop()
+        while len(self.s1):
+            val = self.s1.pop()
+            self.s2.push(val)
+        return self.s2.pop()
+
+
+def test():
+    q = Queue()
+    q.append(1)
+    q.append(2)
+    q.append(3)
+    assert q.pop() == 1
+    q.append(4)
+    assert q.pop() == 2
+    assert q.pop() == 3
+    assert q.pop() == 4
+
+
+if __name__ == '__main__':
+    test()

剑指offer/08_MinNumberInRotatedArray(旋转数组最小数字).py

@@ -0,0 +1,41 @@
+"""
+面试题8：旋转数组的最小数字
+题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
+例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
+"""
+
+
+class Solution:
+    def findMin(self, array):
+        """
+        思路：二分
+        关键点：旋转数组的第一个数字是前半部分最小的，也是后半部分最大的
+        """
+        if len(array) == 1:
+            return array[0]
+        first = array[0]
+        size = len(array)
+        beg = 1
+        end = size
+
+        while beg < end:
+            mid = (beg + end) // 2
+            if array[mid] > first:
+                beg = mid + 1
+            else:
+                end = mid
+        if beg == size:
+            return first
+        else:
+            return array[beg]
+
+
+def test():
+    s = Solution()
+    assert s.findMin([0]) == 0
+    assert s.findMin([1, 2]) == 1  # 注意这个特殊case
+    assert s.findMin([3, 4, 5, 1, 2]) == 1
+
+
+if __name__ == '__main__':
+    test()

剑指offer/10_NumberOf1InBinary(二进制中1的个数).py

@@ -0,0 +1,48 @@
+"""
+面试题10：二进制中1的个数
+题目：请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。例如把9表示成二进制是1001，有2位是1。因此如果输入9，该函数输出2。""
+"""
+
+
+class Solution:
+    def solve_wrong(self, num):
+        """
+        不断右移，每次和1做与运算，结果为1就加1.
+        NOTE：但是输入负数会死循环。
+        """
+        cnt = 0
+        while num:
+            if num & 1:
+                cnt += 1
+            num >>= 1
+        return cnt
+
+    def solve(self, num):
+        """
+        不太能想出来：把一个数字不断和它的 num-1 与运算，能做几次就有几个 1
+        用一条语句判断一个整数是不是2的整数次方。一个整数如果是2的整数次方，那么它的二进制表示中有且只有一位是1，
+        而其他所有位都是0。根据前面的分析，把这个整数减去1之后再和它自己做与运算，这个整数中唯一的1就会变成0。
+        """
+        cnt = 0
+        while num:
+            num = (num - 1) & num
+            cnt += 1
+        return cnt
+
+    def solve_py(self, num):
+        """python有一种比较 tricky 的方式来做
+        """
+        s = format(num, 'b')
+        return s.counts('1')
+
+
+def test():
+    s = Solution()
+    assert s.solve(9) == 2
+    assert s.solve(1) == 1
+    assert s.solve(8) == 1
+    assert s.solve(0) == 0
+
+
+if __name__ == '__main__':
+    test()

剑指offer/12_Print1ToMaxOfNDigits(打印1到最大的n位数).py

@@ -0,0 +1,31 @@
+"""
+面试题12：打印1到最大的n位数
+题目：输入数字n，按顺序打印出从1最大的n位十进制数。比如输入3，则打印出1、2、3一直到最大的3位数即999。
+
+思路：不能上来直接模拟。时间复杂度太大。
+因为 python 其实支持大数字运算，不需要像其他语言一样使用数组模拟大数。
+"""
+
+
+class Solution:
+    def solve(self, n):
+        """递归的思路输出所有排列"""
+        nums = [0] * n
+        self._solve(nums, 0, n)
+
+    def _solve(self, nums, beg, end):
+        if beg == end:
+            print(nums)
+            return
+        for i in range(10):
+            nums[beg] = i
+            self._solve(nums, beg + 1, end)
+
+
+def test():
+    s = Solution()
+    s.solve(9)
+
+
+if __name__ == '__main__':
+    test()