剑指offer经典面试编程题python（P1～P6）

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

注意：
1、判断数组是否为空
2、从左上或者右下开始查找会更快

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        if not array:
            return

        row=len(array)
        col=len(array[0])
        i=0
        j=col-1
        while i<row and j>=0:
            if array[i][j]>target:
                j=j-1
            elif array[i][j]<target:
                i=i+1
            else:
                return True
        return False

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

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

P3 从尾到头打印链表
题目描述
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

注意：
1、判断listNode是否为空
2、数组添加元素的方法：result.extend([value])，result.insert(loc,value)
3、倒序输出result[::-1]

# -*- 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 []
        
        result=[]
        while listNode.next is not None:
            result.extend([listNode.val])
            listNode=listNode.next
        result.extend([listNode.val])
        return result[::-1]

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

注意：
1、在函数内部调用此函数时要有self.XXX()
2、注意理解前序遍历、中序遍历、后序遍历，并知道三者之间与二叉树节点的位置关系

# -*- 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
        
        root=TreeNode(pre[0])
        loc_index=tin.index(pre[0])
        
        root.left=self.reConstructBinaryTree(pre[1:loc_index+1],tin[:loc_index])
        root.right=self.reConstructBinaryTree(pre[loc_index+1:],tin[loc_index+1:])
        
        return root

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

注意：
1、栈是后进先出，队列是先进先出
2、注意init方法前后是两个短下划线

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stackA=[]
        self.stackB=[]
    def push(self, node):
        # write code here
        return self.stackA.append(node)
    def pop(self):
        # return xx
        if self.stackB:
            return self.stackB.pop()
        elif not self.stackA:
            return None
        else:
            while self.stackA:
                self.stackB.append(self.stackA.pop())
            return self.stackB.pop()

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

注意：
1、二分查找。对于原数组是非递减数组的旋转数组而言，若最中间的数大于最右侧的数，则最小值在右边；若最中间的数小于最右侧的数，则最小值在左边

# -*- coding:utf-8 -*-
class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if not rotateArray:
            return 0
        front = 0
        rear = len(rotateArray) - 1

        while front < rear:
            if rotateArray[int((front + rear) / 2)] > rotateArray[rear]:
                front = int((front + rear) / 2) + 1
            else:
                rear = int((front + rear) / 2)
        return rotateArray[front]