剑指 python 实现

1.题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
方法一： 循环迭代查找，不是最优

array= [[1, 2, 3,9],\
     [2, 8, 10,30],\
     [5, 9, 88,99]]
# print(len(array))   3行
# print(len(array[0])) 列
class Solution:
    def Find(self, target, array):
        if not array:
            return
        row = len(array)
        col = len(array[0])
        for i in range(row):
            for j in range(col):
                if target == array[i][j]:
                    return True

        return False
test=Solution()
print(test.Find(99,array))

方法二：上述方法的时间复杂度是O(n^2)，最优化的方式是从左下或者右上开始搜索从右上开始搜索，如果数组中的数比该数要大，那么想左移动一位，如果数组中的数比该数小，向下移动一位，因为数组本身是从左到右依次增大，从上到下一次增大

array= [[1, 2, 3,9],\
     [2, 8, 10,30],\
     [5, 9, 88,99]]
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        raw = len(array)
        col = len(array[0])

        i = 0
        j = col - 1
        while i < raw and j >= 0:
            if array[i][j] > target:
                j -= 1
            elif array[i][j] < target:
                i += 1
            else:
                return True
        return False
test=Solution()
print(test.Find(5,array))

2.题目：请实现一个函数，将一个字符串中的空格替换成“%20”。
例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

s='We Are Happy'
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        return s.replace(' ','%20')

test=Solution()
print(test.replaceSpace(s))

3.从尾到头打印链表
题目：输入一个链表，从尾到头打印链表每个节点的值。

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        l=[]
        while listNode:
            l.append(listNode.val)
            listNode=listNode.next
        return l[::-1]
if __name__=='__main__':
    A1 = ListNode(1)
    A2 = ListNode(2)
    A3 = ListNode(3)
    A4 = ListNode(4)
    A5 = ListNode(5)

    A1.next=A2
    A2.next=A3
    A3.next=A4
    A4.next=A5

    solution=Solution()
    cwf=solution.printListFromTailToHead(A1)
    print(cwf)

4.重建二叉树
题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

# 前序遍历：根--左--右      第一个数字就是根节点的值
# 中序遍历：左--根--右      在根节点的左边就是左子树的值，在右边就是右子树的值。
class TreeNode:
    def __init__(self, x):
        self.val = x

        self.left = None

        self.right = None


class Solution:

    # 返回构造的TreeNode根节点,pre指的是前序遍历，tin是中序遍历

    def reConstructBinaryTree(self, pre, tin):

        # 不写这一行，会报错list index out of range,可能出现了空列表,所以判断如果是空列表，返回None

        if not pre and not tin:
            return None

        # 要考虑到只有一个元素的情况。

        if len(pre) == 1:

            return TreeNode(pre[0])

        else:

            # 根节点就是前序遍历的第一个值,定义一下根节点的值

            root = TreeNode(pre[0])

            # 找一下根节点在中序遍历里的索引，

            i = tin.index(pre[0])

            # 递归，左子树对应的前序和中序的序列

            root.left = self.reConstructBinaryTree(pre[1:i + 1], tin[:i])
            # print(i,pre[1:i + 1], tin[:i])
            # 右子树对应的前序和中序的序列

            root.right = self.reConstructBinaryTree(pre[i + 1:], tin[i + 1:])
            # print(i,pre[i + 1:], tin[i + 1:])
        return root


pre = [1, 2, 4, 7, 3, 5, 6, 8]

tin = [4, 7, 2, 1, 5, 3, 8, 6]

s = Solution()

newTree = s.reConstructBinaryTree(pre, tin)
print(newTree)

5.两个栈实现队列
题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型

class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # 往栈一压入元素
        self.stack1.append(node)
    def pop(self):
        if len(self.stack1) == 0 and len(self.stack2) == 0:
            return
        # 如果栈二为空，把栈一的元素逐个弹出并压入栈二
        elif len(self.stack2) == 0:
            while len(self.stack1) > 0:
                self.stack2.append(self.stack1.pop())
        return self.stack2.pop()
P = Solution()
P.push(5)
P.push(4)
P.push(3)
print(P.pop())
print(P.pop())
print(P.pop())

6.旋转数组的最小数字题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0

class Solution:
    def minNmuber(self,arr):
        if not arr:
            return 0
        left=0
        right=len(arr)-1
        mid=0


        while arr[left]>=arr[right]:
            if right-left==1:
                mid=right
                break

            mid=(left+right)//2
            if arr[left]==arr[mid] and arr[left]==arr[right]:
                return  self.minOrder(left,right,arr)
            if arr[left]<=arr[mid]:
                left=mid
            elif arr[right]>=arr[mid]:
                right=mid

        return arr[right]

    def minOrder(self,left,right,arr):
        rs=arr[0]
        for i in range(left,right+1):
            if arr[i] < rs:
                rs=arr[i]
        return rs

arr=[3,4,5,6,1,2]
arr1=[1,0,1,1,1]
t=Solution()
print(t.minNmuber(arr))
print(t.minNmuber(arr1))

7…斐波那契数列

题目：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。

n<=39

class Solution:
    def fib(self,n):
        rs=[0,1]
        while len(rs) <= n:
            # res.append(res[-1] + res[-2])
            rs.append(rs[-1]+rs[-2])

        return rs[n]

s=Solution()
print(s.fib(3))

8.跳台阶

题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法

'''
对于本题, 前提只有
一次
1
阶或者2阶的跳法。
a.如果两种跳法，1
阶或者2阶，那么假定第一次跳的是一阶，那么剩下的是n - 1
个台阶，跳法是f(n - 1);
b.假定第一次跳的是2阶，那么剩下的是n - 2
个台阶，跳法是f(n - 2)
c.由a\b假设可以得出总跳法为: f(n) = f(n - 1) + f(n - 2)
d.然后通过实际的情况可以得出：只有一阶的时候
f(1) = 1, 只有两阶的时候可以有
f(2) = 2
e.可以发现最终得出的是一个斐波那契数列：

| 1, (n=1)
f(n) = | 2, (n=2)
| f(n - 1) + f(n - 2), (n > 2, n为整数)
28
ms
5632
k
'''


class Solution:
    def jumpFloor(self, number):
        # write code here
        res = [1,2]
        while len(res) <= number:
            res.append(res[-1]+res[-2])
        if number == 1:
            return 1
        else:
            return res[number-1]

9.变态跳台阶

题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

'''
题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法
'''

'''
因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级
跳1级，剩下n-1级，则剩下跳法是f(n-1)
跳2级，剩下n-2级，则剩下跳法是f(n-2)
所以f(n)=f(n-1)+f(n-2)+...+f(1)
因为f(n-1)=f(n-2)+f(n-3)+...+f(1)
所以f(n)=2*f(n-1)
然后求解这个无穷级数的和，正确答案应该是：每次至少跳一个，至多跳n个，一共有f(n)=2**（n-1）种跳法
29ms
5632k
'''

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloorII(self, number):
        # write code here
        return 2**(number-1)

10.矩形覆盖

题目：我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

'''
依旧是斐波那契数列
2*n的大矩形，和n个2*1的小矩形
其中 2*target 为大矩阵的大小
有以下几种情形：
1⃣️target <= 0 大矩形为<= 2*0,直接return 1；
2⃣️target = 1大矩形为2*1，只有一种摆放方法，return1；
3⃣️target = 2 大矩形为2*2，有两种摆放方法，return2；
4⃣️target = n 分为两步考虑：
第一次摆放一块 2*1 的小矩阵，则摆放方法总共为f(target - 1)
√
√
第一次摆放一块1*2的小矩阵，则摆放方法总共为f(target-2)
因为，摆放了一块1*2的小矩阵（用√√表示），对应下方的1*2（用××表示）摆放方法就确定了，所以为f(targte-2)
√	√
×	×
target >= 3  f(n) = f(target - 1) + f(targte-2)
29ms
5632k
'''

# -*- coding:utf-8 -*-
class Solution:
    def rectCover(self, number):
        # write code here
        if number == 0:
            return 0
        elif number == 1:
            return 1
        elif number == 2:
            return 2
        else:
            res = [0, 1, 2]
            while len(res) <= number:
                res.append(res[-1] + res[-2])
            return res[number]