剑指offer

1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

def Find(self, target, array):
        # write code here
        for i in range(len(array)):
            if target in array[i]:
                return True
        return False

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

def replaceSpace(self, s):
        # write code here
        return s.replace(' ','%20')

3.输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

def printListFromTailToHead(self, listNode):
        # write code here
        l = []
        while listNode:
            l.append(listNode.val)
            listNode = listNode.next
        l.reverse()
        return l

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

def reConstructBinaryTree(self, pre, tin):
        # write code here
        if not pre or not tin:
            return None
        root = TreeNode(pre.pop(0))
        index = tin.index(root.val)
        root.left = self.reConstructBinaryTree(pre,tin[:index])
        root.right = self.reConstructBinaryTree(pre,tin[index+1:])
        return root

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

def __init__(self):
        self.stack1 = [] #定义一个模仿入队列
        self.stack2 = [] #定义一个出队列
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        # return xx
        if len(self.stack2) != 0: #判断出队列是否还有值，如果有这弹出反之入队列弹出出队列压入再弹出
            return self.stack2.pop()
        else:
            while len(self.stack1) != 0:
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop()

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

def minNumberInRotateArray(self, rotateArray):
        # write code here
        for i in range(1,len(rotateArray)):
            if rotateArray[i] >= rotateArray[i-1]:
                continue
            else:
                return rotateArray[i]

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

def Fibonacci(self, n):
        # write code here
        if n == 0:
            return 0
        if n == 1:
            return 1
        l = []
        l.append(0)
        l.append(1)
        for i in range(2,n+1):
            l.append(l[i-1] + l[i-2]) #开始用的是l[i] = l[i-1] + l[i-2] 导致列表越界
        return l[n]

8.一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

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

9.略
10.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

def NumberOf1(self, n):
        # write code here
        if n >=0:
            return bin(n).count('1')
        else:
            n = -n #把负数转化为正数
            s = bin(n)[2:] #截掉开始的0b,从第二位开始的
            s = '0'*(32-len(s))+s # 如果求得长度不足32位前边补零
            l = [int(i) for i in s] 
            for i in range(len(l)): #取反
                if l[i] == 1:
                    l[i] = 0
                else:
                    l[i] = 1
            for i in range(len(l)-1,-1,-1): #加一
                if l[i] == 0:
                    l[i] = 1
                    break
                else:
                    l[i] = 0
            return l.count(1)

11.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

def Power(self, base, exponent):
        # write code here
        return base ** exponent

12.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

def reOrderArray(self, array):
        # write code here
        l1 = []
        l2 = []
        for i in array:
            if i % 2 != 0:
                l1.append(i)
            else:
                l2.append(i)
        return l1+l2

13.输入一个链表，输出该链表中倒数第k个结点。

def FindKthToTail(self, head, k):
        # write code here
        if head == None:
            return None
        l = []
        while head:
            l.append(head)
            head = head.next
        if k>len(l) or k == 0:
            return None
        return l[-k]

14.输入一个链表，反转链表后，输出新链表的表头。

def ReverseList(self, pHead):
        # write code here
        if pHead == None or pHead.next == None: # 判断链表为空或者一个节点
            return pHead
        last = None
        while pHead:
            temp = pHead.next #获取下一个节点
            pHead.next = last # 第一个节点的next指向空，剩下节点指向前一个节点实现反转
            last = pHead # last指向反转后的链表的头结点
            pHead = temp # phead指向原剩余节点的头结点
        return last

15.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

def Merge(self, pHead1, pHead2):
        # write code here
        if pHead1 == None and pHead2 == None:
            return None
        p = ListNode(90)
        pHead = p
        while pHead1 and pHead2:
            if pHead1.val > pHead2.val:
                pHead.next = pHead2
                pHead2 = pHead2.next
                pHead = pHead.next
            else:
                pHead.next = pHead1
                pHead1 = pHead1.next
                pHead = pHead.next
        if pHead1:
            pHead.next = pHead1
        if pHead2:
            pHead.next = pHead2
        return p.next

16.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

 def HasSubtree(self, pRoot1, pRoot2):
        # write code here
        if not pRoot1 or not pRoot2:
            return False
        return self.is_subtree(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)
 def is_subtree(self,A,B):
        if not B:
            return True
        if not A or A.val != B.val:
            return False
        return self.is_subtree(A.left,B.left) and self.is_subtree(A.right,B.right)

17.操作给定的二叉树，将其变换为源二叉树的镜像。

def Mirror(self, root):
        # write code here
        if root != None:
            root.left,root.right = root.right,root.left
            self.Mirror(root.left)
            self.Mirror(root.right)
        return root

18.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

def printMatrix(self, matrix):
        # write code here
        res = []
        m = len(matrix) #行数
        n = len(matrix[0]) #列数
        if m == 1 and n == 1:
            return [matrix[0][0]]
        for o in range((min(m,n)+1)//2):
            [res.append(matrix[o][i]) for i in range(o,n-o)]
            [res.append(matrix[j][n-1-o]) for j in range(o,m-o) if matrix[j][n-1-o] not in res]
            [res.append(matrix[m-1-o][k]) for k in range(n-1-o,o-1,-1) if matrix[m-1-o][k] not in res]
            [res.append(matrix[l][o]) for l in range(m-1-o,o-1,-1) if matrix[l][o] not in res]
        return res

19.定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

在这里插入代码片

20.输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）。

def IsPopOrder(self, pushV, popV):
        # write code here
        for i in pushV:
            if i not in popV:
                return False
        res = []
        while len(popV):
            v = popV.pop(0)
            if v not in res:
                while True:
                    p = pushV.pop(0)
                    if p == v:
                        break
                    res.append(p)
            else:
                if v == res[-1]:
                    res.pop()
                else:
                    return False
        return True

21.从上往下打印出二叉树的每个节点，同层节点从左至右打印。

def PrintFromTopToBottom(self, root):
        # write code here
        if root == None:
            return []
        l = [root]
        res = []
        while len(l):
            L = []
            for i in l:
                res.append(i.val)
                if i.left:
                    L.append(i.left)
                if i.right:
                    L.append(i.right)
            l = L
        return res

22.输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

def duplicate(self, numbers, duplication):
        # write code here
        flag = False
        for i in numbers:
            if numbers.count(i) > 1:
                flag = True
                duplication[0] = i
                break
        return flag

23.给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

方法一：
def EntryNodeOfLoop(self, pHead):
        # write code here
        if not pHead:
            return None
        l = []
        while pHead:
            v = pHead.val
            if v in l:
                return pHead
            l.append(v)
            pHead = pHead.next
        return None

方法二：
def EntryNodeOfLoop(self, pHead):
        # write code here
        if not pHead or not pHead.next:
            return None
        fast = pHead
        slow = pHead
        while True:
            fast = fast.next.next
            slow = slow.next
            if fast.val == slow.val:
                break
        fast = pHead
        while True:
            if fast == slow:
                return fast
            fast = fast.next
            slow = slow.next

24.输入两个链表，找出它们的第一个公共结点。

def FindFirstCommonNode(self, pHead1, pHead2):
        # write code here
        p1 = pHead1
        p2 = pHead2
        l = []
        while p1:
            l.append(p1.val)
            p1 = p1.next
        while p2:
            if p2.val in l:
                return p2
            p2 = p2.next
        return None

def FindFirstCommonNode(self, pHead1, pHead2):