剑指offer题解(python版)（更新到第16题）

在牛客网上刷题，坚持暑假刷完（8月31日前）《剑指offer》，变量定义基本与牛客网的相同，有错误，或者有更好的解法都可以与博主联系，会不断优化代码，静待更新。

1.二维数组中的查找

题目描述：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路：根据行列的数据变化规律可以缩减寻找数字的时间复杂度，时间复杂度为O(m+n)，m，n分别为数组的行数与列数。

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        rows, cols= len(array), len(array[0])
        row, col = rows-1, 0
        while row>=0 and col<=cols-1:
            if array[row][col] == target:
                return True
            elif array[row][col]>target:
                row-=1
            else:
                col+=1
        return False

2.替换空格

题目描述：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
进一步描述：在网络编程中，如果 URL 参数中含有特殊字符，如空格、'#'、':' 等，可能导致服务器端无法获得正确的参数值。我们需要这些特殊符号转换成服务器可以识别的字符。转换规则是在 '%' 后面跟上 ASCII 码的两位十六进制的表示。如空格的 ASCII 码是 32，即十六进制的 0x20，因此空格被替换成 "%20" 。再比如 '#' 的 ASCII 码为 35，即十六进制的 0x23，它在 URL 中被替换为 "%32"。再比如 ':' 的 ASCII 码为 50，即十六进制的 0x32，它在 URL 中被替换为 "%32"。
解题思路：利用python string的replace函数，可以感受到python在处理字符上的方便，但是这样仅仅是完成了功能，并没有了解到内部的实现。引入朴素的第二种写法，解法二先计算出空格的个数，将字符串延长，最后利用两个索引， 从后往前，不断为新的字符串赋值，时间复杂度和空间复杂度均为O(n)，n为字符串长度。
注意：python中的sring是不可以修改指定位置的值的，转换为list后，再利用string.join()函数转换为string。

#解法1
# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        if not s:
            return s
        else:
            s = s.replace(' ', '%20')
        return s

#解法2
# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        length = len(s)
        if not s:
            return s
        blankNum = 0
        for i in range(length):
            if s[i] == ' ':
                blankNum+=1
        if not blankNum:
            return s
        s = list(s)
        s+=2*blankNum*' '
        point2 = length+2*blankNum-1
        point1 = length-1
        
        while point1!=point2:
            if s[point1]!=' ':
                s[point2]=s[point1]
                point2-=1
            else:
                s[point2-2:point2+1]='%20'
                point2-=3
            point1-=1
        str = ''.join(s)
        return str

3.从尾到头打印链表

题目描述：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
解题思路：将链表的值读取存储到list里，然后翻转，return。

# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        if not listNode:
            return []
        stack = []
        while listNode:
            stack.append(listNode.val)
            listNode = listNode.next
        stack.reverse()
        return stack

4.重建二叉树

题目描述：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解题思路：前序序列获得根节点，利用根节点和中序序列分割左右子树，对左右子树继续递归。

# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if not pre or not tin:
            return None
        pos = tin.index(pre[0])
        root = TreeNode(pre[0])
        root.left = self.reConstructBinaryTree(pre[1:pos+1],tin[0:pos])
        root.right = self.reConstructBinaryTree(pre[pos+1:],tin[pos+1:])
        return root

5.用两个栈实现队列

题目描述：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路：一个输入栈，一个输出栈。当输入时，将输出栈的值全部输入到输入栈，再压入需要输入的值。输出时，将输入栈中的值全部压入输出栈中。时间复杂度为O(n)。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack1 =[]
        self.stack2 =[]
    def push(self, node):
        while self.stack2:
            temp = self.stack2.pop()
            self.stack1.append(temp)
        self.stack1.append(node)
        # write code here
    def pop(self):
        while self.stack1:
            temp = self.stack1.pop()
            self.stack2.append(temp)
        if self.stack2:
            return self.stack2.pop()
        else:
            return None

6.旋转数组的最小数字

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
解题思路：如果使用min函数，时间复杂度为O(n)，就失去了学习的意义。这题主要考察二分查找。因为旋转数组其实是分成了两段的有序数组。我们所寻找的最小值应该是断点值（当然，全部重复不存在断点）。如何确定一段序列是否存在断点是解题的关键。当nums[0] 在leetcode上有该题的中等难度，和困难难度的题。困难难度是包含重复数字，和本题一样。

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, nums):
             # write code here
        length = len(nums)
        if not length:
            return 0
        elif length==1:
            return nums[0]
        else:
            left=0
            right=length-1
            while leftnums[left] or nums[mid]>nums[right]:
                    left=mid+1    
                elif nums[mid]

7.斐波那契数列

题目描述：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39

解题思路：递归实现太耗时间，斐波那契的的输入变量n可以和计算次数联系起来。n，则计算n次。根据斐波那契的定义，我们无需知道前面所有的值，只需要知道最近两次的值，所以每次往后计算两个数。依此类推，返回a即可。
对于python还有生成器的写法，不过这里不是返回生成器。

# -*- coding:utf-8 -*-
class Solution:

    def Fibonacci(self, n):
        # write code here
        a, b = 0, 1 
        for i in range(n):
            a, b = b, a+b
        return a

8.跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
解题思路：递归实现太耗时间，观察到f(n) = f(n-1)+f(n-2)，斐波那契数列。只是初始值不一样。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloor(self, number):
        # write code here
        if number==0:
            return 0
        a, b = 1, 2
        for i in range(number-1):
            a, b = b, a+b
        return a  

9.变态跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
解题思路：写出公式我们发现f(n)=f(n-1)+f(n-2)+...+f(0)，等价于f(n)=2*f(n-1)，f(0)=1，f(1)=1，f(2)=2。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloorII(self, number):
        # write code here
        a = 1 
        if number <= 0:
            return 0
        for i in range(number-1):
            a = a*2
        return a 

10.矩形覆盖

题目描述：我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
解题思路：首先要进行抽象，也就是区分怎样叫不同的覆盖，我们将n想象成横坐标，发现在每个点上，只有两个选择，走一格和走两格。于是问题被转化成在0~n的路径上，每次只能走一格或者走两格，有多少种办法走到终点。如果用深度遍历的方式会超时。很多递归的题目可以联想到斐波那契数列。这题f(n)=f(n-1)+f(n-2)，n>2，在n=2的时候不满足，因为f(0)=0，特殊处理就好了。

# -*- coding:utf-8 -*-
class Solution:
    def jumpFloorII(self, number):
        # write code here
        a = 1 
        if number <= 0:
            return 0
        for i in range(number-1):
            a = a*2
        return a 

11.二进制中1的个数

题目描述：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
解题思路：首先要意识到这是一道考察位运算的题目，如果没有这个意识，很可能开始循环除2，这样也是可以做的，但是就是要注意负数的情况，这个方法比较繁琐，就不展开了。既然是位运算的题目，不免涉及到移位，与，或，异或等运算符的使用。这里只贴出最优解，二进制中1的个数有几个，就循环几次。具体的分析思路见——位运算之二进制中1的个数。

# -*- coding:utf-8 -*-
class Solution:
    def NumberOf1(self, n):
        count =0
        while n>=-0X80000000 and n!=0:
            n = n&(n-1)
            count+=1
        return count

12.数值的整数次方

题目描述：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
解题思路：这题是实现一个pow函数，注意base为0，正数，负数，exponent为0，正数和负数共九种情况。容易遗漏的是base为0，指数为负数的异常值判断，且0的0次方是无意义的，增加一个标志位判断异常。其它情况下，当指数为负数的时候，转化为绝对值，最后取倒数即可。复杂度和指数的绝对值有关。

# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        # write code here
        self.InvalidInput = False
        
        if base==0 and exponent<=0:
            self.InvalidInput = True
            return 0.0
        result = 1
        e = abs(exponent)
        while e:
            result*=base
            e-=1 
        if exponent == 0 :
            return 1.0
        elif exponent > 0:
            return result
        else:
            return 1/result

这题主要是考察代码的完整性，还有一个更高效的做法。因为我们之前的做法是base一次一次的相乘，而如果得到a的4次方，其实我们不需要a*a*a*a，只要a^2^2，做两次平方。有这个思路，我们可以递归实现更加高效的代码，注意指数的奇偶性。
\(a^n = \begin{cases}a^{n/2}*a^{n/2}&n为偶数\\a^{{(n-1)}/2}*a^{{(n-1)}/2}*a&n为奇数\end{cases}\)

# -*- coding:utf-8 -*-
class Solution:
    def Power(self, base, exponent):
        # write code here
        self.InvalidInput = False
        
        if base==0 and exponent<=0:
            self.InvalidInput = True
            return 0.0

        e = abs(exponent)
        result = self.PowerWithUnsignedExponent(base, e)
        if exponent >= 0:
            return result
        else:
            return 1/result
    def PowerWithUnsignedExponent(self, base, exponent):
        if exponent==0:
            return 1
        elif exponent==1:
            return base
        result = self.PowerWithUnsignedExponent(base, exponent>>1)
        result = result*result
        if exponent&0x1:
            result*=base
        return result

13.调整数组顺序使奇数位于偶数前面

题目描述：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
解题思路：python处理这种问题写法上方便一些，但是时间复杂度在系数上高些，虽然都是线性的。该方法的空间复杂度是O(n)。

# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        # write code here
        arrayodd = [odd for odd in array if odd%2==1]
        arrayeven = [even for even in array if even%2==0]
        return arrayodd+arrayeven

为了降低空间复杂度，我们采用原地的方式，记录下第一个偶数的位置，后续的元素全部插入到该偶数的前面，该偶数位置往后移动一格。array.insert和array.pop的复杂度都是O(n)。交换会改变顺序，而插入不会改变相对顺序，这题如果不要求顺序的话，用双指针就好了，一头一尾。在做这类题的时候，经常会遇到要写多个while的情形，我很容易将一个while写在另一个while的里面，因为满足了第一个条件，再执行第二个，直接思路就是嵌套，但为了写起来方便和阅读起来容易懂，两个while完全可以写成并行的，写成顺序执行，而不是嵌套。

# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        # write code here
        i=0
        j=0
        if 0==len(array)==1: # 数组大小为0或者为1直接返回
            return array
        while i

14.链表中倒数第k个结点

题目描述：输入一个链表，输出该链表中倒数第k个结点。
解题思路：直接遍历链表获得长度，然后再找第k个结点，但是这样做就有点繁琐。可以使用两个指针。但是要注意，当第一个指针出发到第几个时，第二个才开始出发。我们知道倒数第k个结点到最后None结点，还需要k个.next操作，那么我们第一个指针先进行k次.next操作，第二个指针这时候正好赋值为head头结点，此时两个指针一起向后遍历，直到第一个指针到None，第二个指针一定是还差k次next操作到.None的，也就是停在了倒数第k个结点上。
注意点：这种题目虽然思路比较简单，但是要想清楚判断条件对不对，是index==k，还是index==k-1。另外这个题目也考察程序的鲁棒性。输入head有可能是空指针，k可能超过链表的长度，k也可能为0。写代码的时候尽可能一遍想清楚，争取一遍写对，写完整。而不是没想清楚，先写下看运行哪里错了。

# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        index1 = 0 # 指针一
        index2 = 0 # 指针二
        temp1 = head # 结点一
        temp2 = None # 结点二
        if head==None: # 输入head为空指针
            return None
        while temp1:
            index1+=1
            temp1 = temp1.next
            if temp2:
                temp2 = temp2.next
            if index1==k:
                temp2 = head
        if temp2==None: # k超过了链表的长度，这里当k为0时，也是返回None
            return None
        else:
            return temp2

15.反转链表

题目描述：输入一个链表，反转链表后，输出新链表的表头。
解题思路：这里可以直接在原链表上进行反转的操作，记录下前一个结点，当前结点，和后一个结点就好了。但我使用的是头插法，自然就会成为倒序的链表，注意要记录好下一个结点的值，不然当我们将当前结点插入到新的链表后，会失去next信息，就无法进行后序的插入。其次要注意空指针的情况。在写代码过程中，自己要首先想好几个测试用例，确保内心运行一遍无误，再提交，不要养成没写明白就开始提交的习惯。

# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        head = ListNode(0)
        temp = None
        while pHead:
            nextNode = pHead.next
            temp = head.next
            head.next = pHead
            pHead.next = temp
            pHead = nextNode
        return head.next

16.合并两个排序的链表

题目描述：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
解题思路：两种方法。一是选择第一个值小的链表做基准，另一个链表和它不断比较，如果小于，就插入。另外一种方法是递归，两两比较，每次选出值小的结点。注意输入链表为空的情况，在插入时，要特别注意保存当前结点的next值，而不是当前结点。因为保存pCompare到temp了，后面再修改pCompare.next，temp也会跟着改变。应该保存pCompare.next。时间复杂度时O(max(m, n))，m和n分别为两个链表的长度。强调下，递归法只考虑第一层如何运行的，还有写好边界条件。想着其它层如何运行，会很乱。

# 解法一：插入法
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        if pHead1 == None:
            return pHead2
        elif pHead2 == None:
            return pHead1
        
        pNode = pHead1 if pHead1.val<=pHead2.val else pHead2
        pCompare = pHead2 if pHead1.val<=pHead2.val else pHead1
        Head = ListNode(0)
        Head.next = pNode
        pre = Head
        
        while pNode:
            if pCompare:
                if pCompare.val>=pNode.val:
                    pre = pNode
                    pNode = pNode.next
                else:
                    pre.next=pCompare
                    pre = pCompare
                    temp = pCompare.next
                    pCompare.next = pNode
                    pCompare = temp    
            else:
                break
        
        if pCompare:
            pre.next = pCompare
        return Head.next

# 解法二：递归法
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        if pHead1 == None:
            return pHead2
        elif pHead2 == None:
            return pHead1
        
        if pHead1.val <= pHead2.val:
            head = pHead1
            head.next = self.Merge(pHead1.next, pHead2)
        else:
            head = pHead2
            head.next = self.Merge(pHead1, pHead2.next)
        return head