剑指Offer题解_Python

1.二维数组中的查找
2.替换空格
3.从尾到头打印链表
4.重建二叉树
5.用两个栈实现队列
6.旋转数组的最小数字
7.斐波那契数列
8.跳台阶
9.变态跳台阶
10.矩形覆盖
11.二进制中1的个数
12.数值的整数次方
13.调整数组顺序，使奇数位于偶数前面
14.链表中倒数第k个结点
15.反转链表
16.合并两个排序的链表
17.树的子结构
18.二叉树的镜像
19.顺时针打印矩阵
20.包含min函数的栈
21.栈的压入、弹出序列
22.从上往下打印二叉树
23.二叉搜索树的后序遍历序列
24.二叉树中和为某一值的路径
25.复杂链表的复制
26.二叉搜索树与双向链表
27.字符串的排列
28.数组中出现次数超过一半的数字
29.最小的K个数
30.连续子数组的最大和
31.整数中1出现的次数（从1到n整数中1出现的次数）
32.把数组排成最小的数
33.丑数
34.第一个只出现一次的字符
35.数组中的逆序对。
36.两个链表的第一个公共结点
37.数字在排序数组中出现的次数
38.二叉树的深度
39.平衡二叉树
40.数组中只出现一次的数字
41.和为S的连续正数序列
42.和为S的两个数字
43.左旋转字符串
44.翻转单词顺序列
45.扑克牌顺子
46.孩子们的游戏（圆圈中最后剩下的数）
47.求1+2+…+n
48.不用加减乘除做加法
49.把字符串转换成整数
50.数组中重复的数字
51.构建乘积数组
52.正则表达式匹配
53.表示数值的字符串
54.字符流中第一个不重复的字符
55.链表中环的入口结点
56.删除链表中的重复的结点
57.二叉树的下一个结点
58.对称的二叉树
59.按之字形顺序打印二叉树
60.把二叉树打印成多行
61.序列化二叉树
62.二叉搜索树的第k个结点
63.数据流中的中位数
64.滑动窗口的最大值
65.矩阵中的路径
66.机器人的运动范围

1.二维数组中的查找

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

思路：直接枚举时间复杂度为O（n2），不够理想，考虑二分法，将每一行作为一个独立的序列进行二分查找，时间复杂度为O（nlogn）。还有一个比较好的思路，从二维数组的右上角开始，因为数组是从左到右，从上到下递增的，所以从右上角开始考虑，如目标值等于右上角的值，则搜索结束，返回True。如果目标值小于右上角的值，则列数-1，否则行数+1，继续查找。

代码如下：

class Solution:
    # array 二维列表
    def Find(self, target, array):
        row_end=len(array)-1
        col_end=len(array[0])-1
        row=0
        col=col_end
        while(row<=row_end and col>=0):
            if(target==array[row][col]):
                return True
            if(target>array[row][col]):
                row+=1
            else:col-=1
        return False

2.替换空格

问题描述：
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路：可以直接用python的replace函数；或者直接从前往后替换，但是这个时间字符串中的下标会乱，所以用一个新的字符串用于复制；或者从后往前替换，但是要先计算需要的最长字符串长度，感觉这个比较麻烦，所以我只写了前面两种。
代码如下：

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

# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        res=''
        for value in s:
            if value==' ':
                res+='%20'
            else:
                res+=value
        return res

3.从尾到头打印链表

问题描述：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
思路：用一个新的链表new作为最后的输出链表，然后遍历原来的链表，每次遍历的值都插入到new的第一个位置。
代码如下：

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

补充：insert函数——insert() 函数用于将指定对象插入列表的指定位置。
语法：list.insert(index, obj)
index – 对象 obj 需要插入的索引位置。
obj – 要插入列表中的对象。

4.重建二叉树

问题描述：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：这道题要用到递归，每次先找到根节点，如何再用递归方法分别构造左右子树
代码如下：

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre)==0:
            return None
        if len(pre)==1:
            return TreeNode(pre[0])
        else:
            flag=TreeNode(pre[0])
            flag.left=self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1], tin[:tin.index(pre[0])])
            flag.right=self.reConstructBinaryTree(pre[tin.index(pre[0])+1:], tin[tin.index(pre[0])+1:])
        return flag

注意：
a=[1,2,3,4,5,6]
print(a[1:3])
输出结果：[2, 3]
所以flag.left=self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1], tin[:tin.index(pre[0])])这里pre要取pre[1:tin.index(pre[0])+1]

5.用两个栈实现队列

题目描述：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：队列：先进先出。栈：先进后出
push一个元素进入队列，比较容易实现，可以直接push到第一个栈里，不管这时候第一个栈里是否有元素，因为根据栈后进先出的原则，当把元素从第一个栈pop出来push进第二个栈的时候，综述后进来的先被push到第二个栈里，这样后进来的会先沉向第二个栈的栈底，从而导致pop元素的时候还是pop出先进来的元素。要实现从队列里pop出元素根据现进先出的原则，如果第二个栈里有元素则可以直接从第二个栈里pop出来，如果第二个栈里没有元素，就要考虑将刚刚push进第一个栈的元素先push进第二个栈，然后再从第二个栈pop出元素。
代码如下：

class Solution:
    def __init__(self):
        self.stack1=[]
        self.stack2=[]
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        # return xx
        if self.stack2==[]:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
            return self.stack2.pop()
        return self.stack2.pop()

这里我运行了好几次都错了，原来我的__init__函数只写了一个下划线，而其实需要两边各两条下划线（基础不牢，哭瞎）。然后就是写pop函数时，那个while的条件把stack1写成stack2（蠢哭了），这么搞正确率真是有够低。

6.旋转数组的最小数字

题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路：因为是非减排序数组，所以最直接的想法就是遍历数组元素，找到比前一个元素小的元素即最小元素，但是这样时间复杂度是O(n)。由于是排序数组，所以考虑用二分法降低时间复杂度。z这个想法不难，直接可以写出代码。
代码如下：

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        # write code here
        if len(rotateArray)==0:return 0
        low=0
        high=len(rotateArray)-1
        while(low<=high):
            mid=(low+high)/2
            if(rotateArray[mid]<rotateArray[high]):
                high=mid
            elif(rotateArray[mid]==rotateArray[high]):
                high-=1
            else:
                low=mid+1
        return rotateArray[low]

7.斐波那契数列

题目描述：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
思路：斐波那契数列：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）
代码如下：

class Solution:
    def Fibonacci(self, n):
        # write code here
        if(n==0):return 0
        if(n==1):return 1
        if(n==2):return 1
        x=1
        y=1
        for i in range(3,n+1):
            result=x+y
            x=y
            y=result
        return result

注：写了一阵子C++后真的把Python语法忘得差不多了，这么简单的循环差点写不出来，哭唧唧

8.跳台阶

**题目描述**：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。这题在LeetCode里面也见过，但是在剑指里第一次刷的时候我还是写不出来，菜唧唧。 **思路**：其实这和上面那道题一样，也是斐波那契数列，不同的是F(1)=1,F(2)=2，求F(n)时，先分析第一次跳的可能跳法——跳一阶或者两阶，当第一次跳一阶时，则剩下的有F(n-1)种可能，当第一次跳两阶时，剩下的有F(n-2)种跳法，所以F(n)=F(n-1)+F(n-2)，所以可以直接用上一题的思路写这道题。另外一种思路是直接用递归，递归虽然好用，但是太费空间，一般能避免还是避免。 **代码如下**：

class Solution:
    def jumpFloor(self, number):
        # write code here
        if number==0:return 0
        if number==1:return 1
        if number==2:return 2
        x=1
        y=2
        for i in range(3,number+1):
            result=x+y
            x=y
            y=result
        return result

9.变态跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路：这道题是上面那题的升级版，但其实思路是差不多的，先考虑第一次跳的可能性，如果第一次跳1阶，那么就剩下F(n-1)种可能，第一次跳2阶，就剩下F(n-2)种可能…以此类推，如果第一次跳n阶，就只有一种可能，所以F(n)=F(n-1)+F(n-2)+…+1，而同样的，F(n-1)=F(n-2)+…+1，所以F(n)=2*F(n-1)
代码如下：

class Solution:
    def jumpFloorII(self, number):
        # write code here
        if(number==0):return 0
        if(number==1):return 1
        if(number==2):return 2
        return 2*self.jumpFloorII(number-1)

10.矩形覆盖

题目描述：我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
思路：还是斐波那契数列。先考虑第一个小矩形的放法，如果第一个小矩形2的长边贴着大矩形长度为2的边，那么剩下的n-1个有F(n-1)种摆放方式，如果第一个小矩形用边长为1的边贴着大矩形边长为2的边，则它的下面必须还有一个也是这样横着放的小矩形，那么剩下的就只有F(n-2)种放法。所以F(n)=F(n-1)+F(n-2)
代码如下：

class Solution:
    def rectCover(self, number):
        # write code here
        if(number==0):return 0
        if(number==1):return 1
        if(number==2):return 2
        x=1
        y=2
        for i in range(3,number+1):
            result=x+y
            x=y 
            y=result
        return result

11.二进制中1的个数

题目描述：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路：

• 如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
• 把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。

class Solution:
    def NumberOf1(self, n):
        # write code here
        count=0
        while(n&0xffffffff != 0):
            count+=1
            n=n&n-1
        return count

12.数值的整数次方

题目描述：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
思路：用循环直接计算。
代码如下：

class Solution:
    def Power(self, base, exponent):
        # write code here
        result=1
        if(base==0):return False
        if(exponent==0):return 1
        for i in range(abs(exponent)):
                result*=base
        if(exponent<0):result=1/result
        return result

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

题目描述：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
思路：这道题我的想法比较直接，直接遍历数组，然后把奇数依次放在一个新列表res1中，把偶数依次放在列表res2中，然后将res1和res2加起来即可。
代码如下：

class Solution:
    def reOrderArray(self, array):
        # write code here
        if(not array):return []
        res1=[]
        res2=[]
        for value in array:
            if(value%2):res1.append(value)
            else:res2.append(value)
        res=res1+res2
        return res

# -*- coding:utf-8 -*-
class Solution:
    def reOrderArray(self, array):
        # write code here
        if not array:return []
        length=len(array)
        cur=0
        for i in range(length):
            if array[i]%2:
                tmp=array[i]
                for j in range(i-1,cur-1,-1):
                    array[j+1]=array[j]
                array[cur]=tmp
                cur+=1
        return array

这里我遇到了一个小问题，试了几次都不知道如何判断列表为空，百度了以后才知道可以用not array，如果它为真则array为空，它为假，则array非空。

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

题目描述：输入一个链表，输出该链表中倒数第k个结点。
思路：设置一个新表，将链表中的元素全部存入新表中，然后取新表的倒数第k个元素。
代码如下：

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

15.反转链表

题目描述：输入一个链表，反转链表后，输出新链表的表头。
思路：链表真的是硬伤，这道题至少写过两遍，可就是记不住。难度也不大，就是对链表不过熟悉吧。用循环，每次将pHead指向原来的next，并切断pHead与其next的联系。真的很难解释，哭唧唧，这大概就是我一直记不住的原因吧。直接上代码：

class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if(pHead==None or pHead.next==None):return pHead
        last=None
        while(pHead):
            tmp=pHead.next
            pHead.next=last
            last=pHead
            pHead=tmp
        return last

16.合并两个排序的链表

题目描述：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则
思路：
设置一个新的链表作为辅助，每次比较两个链表的当前值，将比较小的放到复制链表里，然后提出值的这个链表的当前值往后移一位，当某一个链表的值都被提取出来以后，将另一个链表剩下的值一次性都放入辅助链表中即可。

代码如下：

# -*- 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
        pHead=ListNode(90)
        p=pHead
        while pHead1 and pHead2:
            if(pHead1.val<=pHead2.val):
                pHead.next=pHead1
                pHead1=pHead1.next
            else:
                pHead.next=pHead2
                pHead2=pHead2.next
            pHead=pHead.next
        if pHead1:
            pHead.next=pHead1
        if pHead2:
            pHead.next=pHead2
        return p.next

17.树的子结构

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

• 从根节点开始，判断B是否是A从当前节点开始的子结构，如果不是，再判断B是不是A的左子树的子结构，否则判断B是不是A的右子树的子结构。
• 判断B是否是A从当前结点开始的子结构。如果此时A匹配完了，或者B的值与A的值不同，那么B就不是A的子结构；若B与A在当前结点相同，此时如果B已经匹配完了，那么B就是A的子结构，如果B还没有匹配完，那么就考虑B的左子树是否是A的左子树的子结构，B的右子树是否是A的右子树的子结构。
  （感觉自己思路并写不清楚，数据结构学的还是不行啊，哭唧唧。）
  代码如下：

class Solution:
    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)

18.二叉树的镜像

题目描述：操作给定的二叉树，将其变换为源二叉树的镜像。

思路：只需要遍历二叉树，每次访问一个结点时，交换其左右孩子。
代码如下：

class Solution:
    # 返回镜像树的根节点
    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)

19.顺时针打印矩阵

题目描述：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
思路：螺旋访问数组是常见的一类题目，还可以变形为螺旋生成n维数组。这类题目思路都是相同的，主要是控制访问每行每列的边界。
　　考虑：用两个变量xnum，ynum分别对访问列方向、行方向上前进步数的限制。ynum初始值为列数， xnum初始值为行数-1。打印具体过程如下：
　　当行列方向可前进步数均不为0并且输出列表长度小于原矩阵元素个数时，循环以下四个方向：
　　→：行方向的打印，坐标y值步进，可前进步数为yum。
　　↓：列方向的打印，坐标x值步进，可前进步数为xnum。
　　走过半圈之后，ynum和xnum都减1，这是很显然的。
　　←：行方向的打印，坐标y值后退，为了保证与→ 方向数据不重合，需要加上xnum>=0的判断，这个判断的意思是上边界与下边界之间有间隔，因为如果此时只剩一行数据，那么意味着列方向可前进步数为0，即上一步的xnum = 0 - 1 = -1
　　↑：行方向的打印，坐标x值后退，为了保证与↓ 方向数据不重合，需要加上ynum>=0的判断，这个判断的意思是左边界与右边界之间有间隔，同上。

这题一直没写出来，思路来自：https://blog.csdn.net/qq_20141867/article/details/80902980

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result=[]#保存最后的结果
        m=len(matrix)#行数
        n=len(matrix[0])#列数
        x=0
        y=-1
        ystep=n#y能移动的步数
        xstep=m-1#x能移动的步数
        #因为x从0开始，所以最多移动m-1步，y从-1开始，所以最多移动n步
        while len(result)<m*n and ystep>=0 and xstep>=0:
            for i in range(ystep):
                y+=1
                result.append(matrix[x][y])
            for i in range(xstep):
                x+=1
                result.append(matrix[x][y])
            ystep-=1
            xstep-=1
            if xstep>=0:#若xstep<0，则此时没有剩余的行可以走，从而y不能移动
                for i in range(ystep):
                    y-=1
                    result.append(matrix[x][y])
                ystep-=1#又走过了一行，所以此时y能移动的最大步数要减1
            if ystep>=0:#若ystep<0,此时没有剩余的列可以走，故x不能移动
                for i in range(xstep):
                    x-=1
                    result.append(matrix[x][y])
                xstep-=1#又走过了一列，所以此时x能移动的最大步数要减1
        return result

20.包含min函数的栈

题目描述：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O(1)）。
思路：设置一个辅助栈，用于存储栈中当前最小值，由于在pop出元素的时候，当前最小值可能被pop出来，所以要保证辅助栈与原栈的元素始终保持一致并且最小值在辅助栈与原栈中第一次出现的位置要相同，这样才能保证不论原栈何时将最小值pop出来，在辅助栈中当前最小值也会被pop出来。
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack=[]
        self.min_stack=[]
    def push(self, node):
        # write code here
        self.stack.append(node)
        if self.min_stack==[] or node<self.min():
            self.min_stack.append(node)
        else:
            tmp=self.min()
            self.min_stack.append(tmp)
            #要保持stack与min_stack的长度相同，并且后面弹出时，如果stack的最小值被弹出，
            #则min_stack里的最小值也要被弹出
    def pop(self):
        # write code here
        if self.min_stack==[]:
            return None
        self.stack.pop()
        self.min_stack.pop()
    def top(self):
        # write code here
        return self.stack[-1]
    def min(self):
        # write code here
        return self.min_stack[-1]

21.栈的压入、弹出序列

题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
思路：借用一个辅助的栈，遍历压栈顺序，先讲第一个放入栈中，这里是1，然后判断栈顶元素是不是出栈顺序的第一个元素，这里是4，很显然1≠4，所以我们继续压栈，直到相等以后开始出栈，出栈一个元素，则将出栈顺序向后移动一位，直到不相等，这样循环等压栈顺序遍历完成，如果辅助栈还不为空，说明弹出序列不是该栈的弹出顺序。

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def IsPopOrder(self, pushV, popV):
        # write code here
        stack=[]
        while popV:
            if stack and stack[-1]==popV[0]:
                stack.pop()
                popV.pop(0)
            elif pushV:
                stack.append(pushV.pop(0))
            else:
                return False
        return True

22.从上往下打印二叉树

题目描述：从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：利用队列的先进先出(FIFO)特性解决。每从队列头部获取一个节点，就将该节点的左右子节点存入队列的尾部。如此往复，直至队列为空。https://blog.csdn.net/u010005281/article/details/79493413

代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        queue=[]
        result=[]
        if root==None:return result
        queue.append(root)
        while queue:
            newnode=queue.pop(0)
            result.append(newnode.val)
            if newnode.left!=None:
                queue.append(newnode.left)
            if newnode.right!=None:
                queue.append(newnode.right)
        return result

23.二叉搜索树的后序遍历序列

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

• 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
• 把数组分成三部分，比如[4,8,6,12,16,14,10]，10就是根节点，4,8,6都是左子树，12,16,14,10都是右子树，然后针对左右子树再去判断是不是符合根节点、左右子树这一个规律（左子树都比根节点小，右子树都比根节点大）
  代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        l=len(sequence)
        if l<=0:return False
        index=l-1
        for i in range(l):
            if sequence[i]>sequence[-1]:
                index=i
                break
        for i in range(i,l):
            if sequence[i]<sequence[-1]:
                return False
        left=True
        right=True
        if len(sequence[:index])>0:
            left=self.VerifySquenceOfBST(sequence[:index])
        if len(sequence[index:-1])>0:
            right=self.VerifySquenceOfBST(sequence[index:-1])
        return left and right

24.二叉树中和为某一值的路径

题目描述：输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
思路：
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def __init__(self):
        self.onePath = []
        self.PathArray = []
    def FindPath(self, root, expectNumber):
        if root is None:
            return self.PathArray
        self.onePath.append(root.val)
        expectNumber -= root.val
        if expectNumber==0 and not root.left and not root.right:
            self.PathArray.append(self.onePath[:])
        elif expectNumber>0:
            self.FindPath(root.left,expectNumber)
            self.FindPath(root.right,expectNumber)
        self.onePath.pop()
        return self.PathArray

25.复杂链表的复制

题目描述：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
思路：
代码如下：

# -*- coding:utf-8 -*-
# class RandomListNode:
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None
class Solution:
    # 返回 RandomListNode
    def Clone(self, pHead):
        # write code here
        if not pHead:
            return pHead
        cloNode = pHead
        while cloNode:
            node = RandomListNode(cloNode.label)
            node.next = cloNode.next
            cloNode.next = node
            cloNode = node.next
        cloNode = pHead
        while cloNode:
            node = cloNode.next
            if cloNode.random:
                node.random = cloNode.random.next
            cloNode = node.next
        cloNode = pHead
        pHead = pHead.next
        while cloNode.next:
            node = cloNode.next
            cloNode.next = node.next
            cloNode = node
        return pHead

26.二叉搜索树与双向链表

题目描述：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
思路：首先要知道二叉搜索树的中序遍历序列就是排序的数列,之后只需要把当前节点的右子树设为下一个节点,下一个节点的左子树设为该节点.
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Convert(self, pRootOfTree):
        # write code here
        if not pRootOfTree:
            return None
        mid=[]
        self.midnode(pRootOfTree,mid)
        for i in range(len(mid)-1):
            mid[i].right=mid[i+1]
            mid[i+1].left=mid[i]
        return mid[0]
    def midnode(self,root,mid):
        if root==None:
            return None
        if root.left:
            self.midnode(root.left,mid)
        mid.append(root)
        if root.right:
            self.midnode(root.right,mid)

27.字符串的排列

题目描述：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路：利用递归的思想，每次取一个字母打头，然后将剩下的进行全排列，把所有可能组合起来就可以了。
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def Permutation(self, ss):
        # write code here
        if len(ss)<=1:
            return ss
        l=len(ss)
        result=[]
        for i in range(l):
            for j in self.Permutation(ss[0:i]+ss[i+1:]):
                result.append(ss[i]+j)
        return sorted(set(result))

28.数组中出现次数超过一半的数字

题目描述：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
思路：
代码如下：

class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        if numbers is None:return 0
        l=len(numbers)/2
        for value in numbers:
            if numbers.count(value)>l:
                return value
        return 0

29.最小的K个数

题目描述：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
思路：先将列表排序，然后返回前K个数
代码如下：

class Solution:
    def GetLeastNumbers_Solution(self, tinput, k):
        # write code here
        if tinput is None:
            return
        #n = len(tinput)
        if len(tinput) < k:
            return []
        tinput.sort()
        return tinput[:k]

30.连续子数组的最大和

题目描述：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
思路：遍历数组，设置一个当前和sums，设置一个当前最大和maxsum，然后把数组里的元素一个数一个数加起来，当当前的和sums小于0时，将sums设置为0，因为此时再往后加没有意义，一个小于0的数只会使后面的和更小，所以还不如从这里断开，然后从下一个元素开始进行加和。
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def FindGreatestSumOfSubArray(self, array):
        # write code here
        sums=0
        maxsum=array[0]
        for value in array:
            sums+=value
            if maxsum<sums:
                maxsum=sums
            if sums<0:
                sums=0
        return maxsum

31.整数中1出现的次数（从1到n整数中1出现的次数）

题目描述：求出1-13的整数中1出现的次数,并算出100-1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
思路：
代码如下：

32.把数组排成最小的数

题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
思路：只需注意一点，两个数字谁排在前，完全取决于他们谁在前拼起来的数字比较小。
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def PrintMinNumber(self, numbers):
        # write code here
        if len(numbers)<1:return ""
        lmp=lambda n1,n2:int(str(n1)+str(n2))-int(str(n2)+str(n1))
        array=sorted(numbers,cmp=lmp)
        return "".join([str(i) for i in array ])

33.丑数

题目描述：把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
思路：
丑数列表：1

• 2*1
• 3*1
• 5*1
  取最小的2

丑数列表：1,2

• 2*2
• 3*1
• 5*1
  取最小的3

丑数列表：1,2,3

• 2*2
• 3*2
• 5*1
  取最小的4

丑数列表：1,2,3,4

• 2*3
• 3*2
• 5*1
  取最小的5

…
以此类推，每次取到2u2,3u3,5u5后，接下来比较大的丑数应该在2(u2后面的那个丑数）,3*(u3后面那个丑数）,5*(u5后面那个丑数)之间取。
代码如下：

class Solution:
    def GetUglyNumber_Solution(self, index):
        # write code here
        if(index==0):return 0
        ugly=[1]
        i2=i3=i5=0
        count=1
        while count<index:
            minu=min(ugly[i2]*2,min(ugly[i3]*3,ugly[i5]*5))
            ugly.append(minu)
            if ugly[i2]*2<=minu:i2+=1
            if ugly[i3]*3<=minu:i3+=1
            if ugly[i5]*5<=minu:i5+=1
            count+=1
        return ugly[-1]

34.第一个只出现一次的字符

题目描述：在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）。
思路：直接用count函数依次计算列表中各个元素出现的次数，将出现次数为1的字符返回
代码如下：

class Solution:
    def FirstNotRepeatingChar(self, s):
        # write code here
        if not s or len(s)>10000:return -1
        for i in s:
            if s.count(i)==1:return s.index(i)
        return -1

35.数组中的逆序对

题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
输入描述：
题目保证输入的数组中没有的相同的数字
数据范围：

对于%50的数据,size<=10^4

对于%75的数据,size<=10^5

对于%100的数据,size<=2*10^5

思路：拷贝该数组后对拷贝的数组排序。计算数组中的最小值在原始数组中出现的位置，统计原始数组中最小值前面的个数，之后在原始数组中去掉最小值。重复上述步骤。
代码如下：

def InversePairs(self, data):
    sortData = sorted(data)
    count = 0
    for i in sortData:
        pos = data.index(i)
        count += pos
        data.pop(pos)
    return count

36.两个链表的第一个公共结点

题目描述：输入两个链表，找出它们的第一个公共结点。
思路：将第一个链表的元素全部存入一个列表中，然后遍历第二个链表，判断第二个链表的元素是否在列表中，返回第一个在列表中的元素。
代码如下：

class Solution:
    def FindFirstCommonNode(self, pHead1, pHead2):
        # write code here
        L=[]
        while pHead1:
            L.append(pHead1.val) 
            pHead1=pHead1.next
        while pHead2:
            if pHead2.val in L:return pHead2
            else:pHead2=pHead2.next

37.数字在排序数组中出现的次数

题目描述：统计一个数字在排序数组中出现的次数。
思路：我的第一个想法是用count函数简单粗暴。第二个想法是遍历data里的元素，直接计算k出现的次数。由于是排序数组，还考虑用二分法，先查找重复数字中最左边的那个数字位置，再查找重复数字最右边的那个数字位置，然后两个数字相减再加1就得到重复次数。
代码如下：

class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        return data.count(k)

class Solution:
    def GetNumberOfK(self, data, k):
        # write code here
        count=0
        for value in data:
            if value==k:count+=1
        return count

class Solution:
    def GetNumberOfK(self, data, k):
        left=0
        right=len(data)-1
        leftk=self.getleftK(data,k,left,right)
        rightk=self.getrightK(data,k,left,right)
        return rightk-leftk+1
    def getleftK(self,data,k,left,right):###查找重复数字中最左边的那个数字位置
        while left<=right:
            middle=(left+right)//2
            if data[middle]<k:
                left=middle+1
            else:
                right=middle-1
        return left
    def getrightK(self,data,k,left,right):###查找重复数字最右边的那个数字位置
        while left<=right:
            middle=(left+right)//2
            if data[middle]<=k:
                left=middle+1
            else:
                right=middle-1
        return right

38.二叉树的深度

题目描述：输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路：用递归，分别计算左右子树的深度，然后取最大
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def TreeDepth(self, pRoot):
        # write code here
        depth=0
        if pRoot==None:
            return depth
        depth+=1
        depth+=max(self.TreeDepth(pRoot.left),self.TreeDepth(pRoot.right))
        return depth

39.平衡二叉树

题目描述：输入一棵二叉树，判断该二叉树是否是平衡二叉树。
思路：平衡二叉树的定义是任何节点的左右子树高度差都不超过1的二叉树。
代码如下：

*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code here
        if not pRoot:return True
        left=self.Treedepth(pRoot.left)
        right=self.Treedepth(pRoot.right)
        if abs(left-right)>1:return False
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
    def Treedepth(self,pRoot):
        if not pRoot:return 0
        left=self.Treedepth(pRoot.left)
        right=self.Treedepth(pRoot.right)
        return max(left,right)+1

40.数组中只出现一次的数字

题目描述：一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
思路：我的想法还是简单粗暴，用count函数。百度了一下，有解法是用Counter函数的，这里先补充一下关于Counter的一些内容（学Python的基础知识的时候学过，但是太久没用真的忘光了。）
Counter（计数器）是对字典的补充，用于追踪值的出现次数。
Counter是一个继承了字典的类（Counter（dict））
示例：

import collections
c=collections.Counter('ABACB')
print(c)

输出：Counter({'A': 2, 'B': 2, 'C': 1})
代码如下：
我的解法：

class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        L=[]
        for value in array:
            if array.count(value)==1:L.append(value)
        return L[0],L[1]

用Counter解法：

import collections
class Solution:
    # 返回[a,b] 其中ab是出现一次的两个数字
    def FindNumsAppearOnce(self, array):
        # write code here
        L=[]
        D=collections.Counter(array)
        for key,value in D.items():
            if value==1:
                L.append(key)
        return L

41.和为S的连续正数序列

题目描述：小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
思路：下图来自CSDN博主“负雪明烛”的博客，很惭愧，这道题完全没有好的思路，只能直接百度，这种双指针想法真是很厉害。

class Solution:
    def FindContinuousSequence(self, tsum):
        left=1
        right=2
        curr_sum=left+right
        result=[]
        lmax=(tsum+1)/2
        while left<lmax:
            if curr_sum==tsum:result.append(range(left,right+1))
            while curr_sum>tsum and left<lmax:
                curr_sum-=left
                left+=1
                if curr_sum==tsum:result.append(range(left,right+1))
            right+=1
            curr_sum+=right
        return result

42.和为S的两个数字

题目描述：输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
思路：把两个数字想成矩形的两条边，根据中学的知识，当两条边越接近，面积越大（乘积越大）。由于从两头向中间进行查找的，找到的第一个组合一定是边差距最大的，所以乘积最小。
代码如下：

class Solution:
    def FindNumbersWithSum(self, array, tsum):
        # write code here
        if not array:return []
        left,right=0,len(array)-1
        while left<right:
            _sum=array[left]+array[right]
            if _sum<tsum:
                left+=1
            elif _sum>tsum:
                right-=1
            else:
                return [array[left],array[right]]
        return []

43.左旋转字符串

题目描述：汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
思路：现将0—n-1翻转，然后将n-1—len()-1翻转，最后全部翻转
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s:return s
        s=list(s)
        self.reverse(s,0,n-1)
        self.reverse(s,n,len(s)-1)
        self.reverse(s,0,len(s)-1)
        return "".join(s)
    def reverse(self,s,start,end):
        while start<end:
            s[start],s[end]=s[end],s[start]
            start+=1
            end-=1

# -*- coding:utf-8 -*-
class Solution:
    def LeftRotateString(self, s, n):
        # write code here
        if not s:return s
        length=len(s)
        if n==length:return s
        return s[n:]+s[:n]

44.翻转单词顺序列

题目描述：牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
思路：按空格切分为数组，翻转数组，再用空格连接
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def ReverseSentence(self, s):
        # write code here
        if s is None or len(s) == 0:
            return s
        a=s.split(' ')
        return " ".join(a[::-1])
        #return " ".join(s.split(' ')[::-1])

45.扑克牌顺子

题目描述：LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
思路：要得到顺子，有两个要求：

• 五张牌没有重复
• 王牌的个数大于等于顺子中空缺的位子

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def IsContinuous(self, numbers):
        # write code here
        if len(numbers)==0:return False
        numbers.sort()
        num0=numbers.count(0)
        numq=0
        for i in range(num0,len(numbers)-1):
            if numbers[i+1]==numbers[i]:return False
            if numbers[i+1]==numbers[i]+1:continue
            else:
                numq+=numbers[i+1]-numbers[i]-1
        if numq<=num0:return True
        else: return False

46.孩子们的游戏（圆圈中最后剩下的数）

题目描述：每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
思路：

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def LastRemaining_Solution(self, n, m):
        # write code here
        if n<1 or m<1:return -1
        last=0
        for i in range(2,n+1):
            last=(last+m)%i
        return last

47.求1+2+..+n

题目描述：求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
思路：用Python内置sum函数，简单粗暴。然后百度了一下另外的方法，就是利用逻辑与的短路特性实现递归终止。
代码如下：

class Solution:
    def Sum_Solution(self, n):
        # write code here
        return sum(list(range(1,n+1)))

# -*- coding:utf-8 -*-
class Solution:
    def Sum_Solution(self, n):
        # write code here
        return n and n + self.Sum_Solution(n-1)

48.不用加减乘除做加法

题目描述：写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
思路：我的想法还是用python的内置函数sum，简单粗暴
首先看十进制是如何做的： 5+7=12，三步走
第一步：相加各位的值，不算进位，得到2。
第二步：计算进位值，得到10. 如果这一步的进位值为0，那么第一步得到的值就是最终结果。

    第三步：重复上述两步，只是相加的值变成上述两步的得到的结果2和10，得到12。

同样我们可以用三步走的方式计算二进制值相加： 5-101，7-111

    第一步：相加各位的值，不算进位，得到010， 二进制每位相加就相当于各位做异或操作，101^111。

    第二步：计算进位值，得到1010，相当于各位做与操作得到101，再向左移一位得到1010，(101&111)<<1。

   第三步重复上述两步， 各位相加 010^1010=1000，进位值为100=(010&1010)<<1。继续重复上述两步：

   1000^100 = 1100，进位值为0，跳出循环，1100为最终结果。
   
   上述过程在使用Python实现的过程中，对于正整数是没有问题的，但是对于负数，会出现死循环情况。这是为什么呢？因为在Python中，对于超出32位的大整数，会自动进行大整数的转变，这就导致了在右移位过程中，不会出现移到了0的情况，也就会造成了死循环。

 这里需要了解的是Python中整数实现的原理以及二进制中的移位等原理。

 已经知道了右移过程中大整数的自动转化，导致变不成0，那么只需要在移动的过程中加一下判断就行了，把craay的值和0xFFFFFFFF做一下比较就可以了，具体代码如下所示。

class Solution:
    def Add(self, num1, num2):
        # write code here
        return sum([num1,num2])

# -*- coding:utf-8 -*-
class Solution:
    def Add(self, num1, num2):
        # write code here
        carry = 1
        while carry:
            s = num1 ^ num2
            carry = 0xFFFFFFFF & ((num1 & num2) << 1)         
            carry = -(~(carry - 1) & 0xFFFFFFFF) if carry > 0x7FFFFFFF else carry
            num1 = s
            num2 = carry
        return num1

49.把字符串转换成整数

题目描述：将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
思路：

• 解题时需考虑字符串首的符号位；
• 须知：字符“0”对应的ASCII码为48。对获得的字符串中的每个字符，求其ASCII码，减去48即为对应位上的数值。

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def StrToInt(self, s):
        # write code here
        if not s:return 0
        flag=1
        mult=1
        res=0
        if s[0]=='-' or s[0]=='+':
            if s[0]=='-':
                flag=-1
            s=s[1:]
        for value in s[::-1]:
            if '0'<=value<='9':
                res+=(ord(value)-48)*mult
                mult*=10
            else:return 0
        return res*flag

50.数组中重复的数字

题目描述：在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
思路：我的思路还是直接用python的内置函数count
代码如下：

class Solution:
    # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
    # 函数返回True/False
    def duplicate(self, numbers, duplication):
        # write code here
        for value in numbers:
            if numbers.count(value)>1:
                duplication.insert(0,value)
                return True
        return False

51.构建乘积数组

题目描述：给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。

思路：
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def multiply(self, A):
        # write code here
        if not A:return []
        num=len(A)
        B=[None]*num
        B[0]=1
        for i in range(1,num):
            B[i]=B[i-1]*A[i-1]
        tmp=1
        for i in range(num-2,-1,-1):
            tmp*=A[i+1]
            B[i]*=tmp
        return B

52.正则表达式匹配

题目描述：请实现一个函数用来匹配包括’.'和*‘正则表达式。模式中的字符’.'表示任意一个字符，而*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配
思路：
本题就是很直观的字符串的匹配，难点在于当遇到模式中两个特殊字符怎么处理和对于各种形式字符串的全面考虑。这里采用递归的方式，每次只匹配s中一个字符（模式串pattern， 被匹配字符串s）：
处理判断过程如下：

• 如果 s和pattern都为空，匹配成功
• 如果pattern是空串，而s不是，匹配失败
• 如果s，pattern均不是空串(长度至少为1)，考虑到pattern中‘ *
  ’前字符可以出现0次，所以不能简单比较s和pattern的第一个字符是否相等，这里分为两种情况考虑：
• 如果pattern的第二个字符是‘ * ’：
  如果s与pattern的第一个字符匹配（即s与pattern的第一个字符相等或者pattern第一个字符为‘ . ’），剩余部分有两种匹配方式：(1). s后移一位，相当于认为‘ * ’前的字符在s中出现不止一次，(2).pattern后移两位，相当于认为‘ * ’前的字符在s中只出现一次。
• 否则模式串pattern后移两位，相当于认为‘ * ’前的字符在s中出现了0次；
• 如果pattern的第二个字符不是‘ * ’：如果s与pattern的第一个字符匹配（含义同上），s和pattern同时后移一位，继续匹配；否则匹配失败

代码如下：

class Solution:
    # s, pattern都是字符串
    def match(self, s, pattern):
        # write code here
        if len(s) == 0 and len(pattern) == 0:
            return True
        if len(s) > 0 and len(pattern) == 0:
            return False
        # 如果模式第二个字符是*
        if len(pattern) > 1 and pattern[1] == '*':
            if len(s) > 0 and (s[0] == pattern[0] or pattern[0] == '.'):
                # 如果第一个字符匹配，三种可能1、模式后移两位；2、字符串移1位
                return self.match(s, pattern[2:]) or self.match(s[1:], pattern)
            else:
                # 如果第一个字符不匹配，模式往后移2位，相当于忽略x*
                return self.match(s, pattern[2:])
        # 如果模式第二个字符不是*
        if len(s) > 0 and (s[0] == pattern[0] or pattern[0] == '.'):
            return self.match(s[1:], pattern[1:])
        else:
            return False

53.表示数值的字符串

题目描述：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
思路：用异常处理
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    # s字符串
    def isNumeric(self, s):
        # write code here
        try:
            p=float(s)
            return True
        except:
            return False

54.字符流中第一个不重复的字符

题目描述：请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
思路：还是用count
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    # 返回对应char
    def __init__(self):
        self.charlist=[]
    def FirstAppearingOnce(self):
        # write code here
        for value in self.charlist:
            if self.charlist.count(value)==1:
                return value
        return '#'
    def Insert(self, char):
        # write code here
        self.charlist.append(char)

55.链表中环的入口结点

题目描述：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
思路：

代码如下：

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        if not pHead or pHead.next==None or pHead.next.next==None:
            return None
        pFast=pHead.next.next
        pSlow=pHead.next
        while pFast!=pSlow and pFast.next!=None:
            pSlow=pSlow.next
            pFast=pFast.next.next
        if pFast==pSlow:
            pFast=pHead
            while pFast!=pSlow:
                pFast=pFast.next
                pSlow=pSlow.next
            return pFast
        return None

56.删除链表中的重复的结点

题目描述：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路：
代码如下：

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def deleteDuplication(self, pHead):
        # write code here
        if pHead==None or pHead.next==None:return pHead
        current=pHead.next
        if current.val!=pHead.val:
            pHead.next=self.deleteDuplication(pHead.next)
        else:
            while pHead.val==current.val and current.next!=None:
                current=current.next
            if pHead.val!=current.val:
                pHead=self.deleteDuplication(current)
            else:
                return None
        return pHead

57.二叉树的下一个结点

题目描述：给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路：
分析二叉树的下一个节点，一共有以下情况：

1.二叉树为空，则返回空；

2.节点右孩子存在，则设置一个指针从该节点的右孩子出发，一直沿着指向左子结点的指针找到的叶子节点即为下一个节点；

3.节点不是根节点。如果该节点是其父节点的左孩子，则返回父节点；否则继续向上遍历其父节点的父节点，重复之前的判断，返回结果。

代码如下：

# -*- coding:utf-8 -*-
# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def GetNext(self, pNode):
        # write code here
        if not pNode:return None
        if pNode.right:
            pNode=pNode.right
            while pNode.left:
                pNode=pNode.left
            return pNode
        else:
            while pNode.next:
                if pNode==pNode.next.left:return pNode.next
                pNode=pNode.next
        return None

58.对称的二叉树

题目描述：请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
思路：画棵树就能理解了，蛮直观的。
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def isSymmetrical(self, pRoot):
        # write code here
        if not pRoot:return True
        return self.recursiveTree(pRoot.left,pRoot.right)
        
    def recursiveTree(self, left, right):
        if not left and not right:
            return True
        if not left or not right:
            return False
        if left.val==right.val:
            return self.recursiveTree(left.left,right.right) and self.recursiveTree(left.right,right.left)
        return False

59.按之字形顺序打印二叉树

题目描述：请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
思路：
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if not pRoot:return []
        res=[]
        self.level(pRoot,0,res)
        return res
    def level(self,root,level,res):
        if level==len(res):
            res.append([])
        res[level].append(root.val)
        if root.left:
            self.level(root.left,level+1,res)
        if root.right:
            self.level(root.right,level+1,res)
         

60.把二叉树打印成多行

题目描述：从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
思路：用递归进行层次遍历即可
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if not pRoot:return []
        res=[]
        self.level(pRoot,0,res)
        return res
    def level(self,root,level,res):
        if level==len(res):
            res.append([])
        res[level].append(root.val)
        if root.left:
            self.level(root.left,level+1,res)
        if root.right:
            self.level(root.right,level+1,res)

61.序列化二叉树

题目描述：请实现两个函数，分别用来序列化和反序列化二叉树
思路：
序列化二叉树：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串。需要注意的是，序列化二叉树的过程中，如果遇到空节点，需要以某种符号（这里用#）表示。以下图二叉树为例，序列化二叉树时，需要将空节点也存入字符串中。
反序列化二叉树：根据某种遍历顺序得到的序列化字符串，重构二叉树。具体思路是按前序遍历“根左右”的顺序，根节点位于其左右子节点的前面，即非空（#）的第一个节点是某子树的根节点，左右子节点在该根节点后，以空节点#为分隔符。

代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
from collections import deque
class Solution:
    def Serialize(self, root):
        vals = []
        def preOrder(root):
            if not root:
                vals.append('#')
            else:
                vals.append(str(root.val))
                preOrder(root.left)
                preOrder(root.right)
        preOrder(root)
        return ' '.join(vals)

    def Deserialize(self, s):
        vals = deque(val for val in s.split())
        def build():
            if vals:
                val = vals.popleft()
                if val == '#':
                    return None
                root = TreeNode(int(val))
                root.left = build()
                root.right = build()
                return root
        return build()

62.二叉搜索树的第k个结点

题目描述：给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
思路：因为二叉搜索树中序遍历就是递增序列，所以先将二叉搜索树进行中序遍历，然后取第k个值。
代码如下：

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回对应节点TreeNode
    def KthNode(self, pRoot, k):
        # write code here
        if not pRoot or k<=0:return None
        res=[]
        self.midorder(pRoot,res)
        if k>len(res):return None
        return res[k-1]
    def midorder(self,root,res):
        if not root:return None
        if root.left:
            self.midorder(root.left,res)
        res.append(root)
        if root.right:
            self.midorder(root.right,res)

63.数据流中的中位数

题目描述：如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
思路：
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.data=[]
    def Insert(self, num):
        # write code here
        self.data.append(num)
        self.data.sort()
    def GetMedian(self,data):
        # write code here
        l=len(self.data)
        if l%2:
            return self.data[int(l//2)]
        else:
            return (self.data[l//2]+self.data[l//2-1])/2.0

64.滑动窗口的最大值

题目描述：给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
思路：
代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def maxInWindows(self, num, size):
        # write code here
        if size<=0:return []
        res=[]
        for i in range(0,len(num)-size+1):
            res.append(max(num[i:i+size]))
        return res

65.矩阵中的路径

题目描述：请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
思路：

• 首先遍历起点，当起点与第一个字符相同开始探索；
• 设计探索函数，确定约束条件：是否越过边界and探索值是否是需要的值

代码如下：

# -*- coding:utf-8 -*-
class Solution:
    def hasPath(self, matrix, rows, cols, path):
        # write code here
        for i in range(rows):
            for j in range(cols):
                if matrix[i*cols+j]==path[0]:
                    if self.findpath(list(matrix),rows,cols,path[1:],i,j):
                        return True
    def findpath(self,matrix,rows,cols,path,i,j):
        if not path:return True
        matrix[i*cols+j]=0
        if j+1<cols and matrix[i*cols+j+1]==path[0]:
            return self.findpath(matrix,rows,cols,path[1:],i,j+1)
        elif j-1>=0 and matrix[i*cols+j-1]==path[0]:
            return self.findpath(matrix,rows,cols,path[1:],i,j-1)
        elif i+1<rows and matrix[(i+1)*cols+j]==path[0]:
            return self.findpath(matrix,rows,cols,path[1:],i+1,j)
        elif i-1<rows and matrix[(i-1)*cols+j]==path[0]:
            return self.findpath(matrix,rows,cols,path[1:],i-1,j)
        else:
            return False

66.机器人的运动范围

题目描述：地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
思路：当准备进入坐标(i,j)是，通过检查坐标的数位来判断机器人能否进入。如果能进入的话，接着判断四个相邻的格子。

代码描述：

# -*- coding:utf-8 -*-
class Solution:
    def movingCount(self, threshold, rows, cols):
        # write code here
        matrix = [[0 for i in range(cols)] for j in range(rows)]
        count=self.findgrid(threshold,rows,cols,matrix,0,0)
        print matrix
        return count
    def judge(self,threshold,i,j):
        if sum(map(int,str(i)+str(j))) <= threshold:
            return True
        else:
            return False
    def findgrid(self,threshold,rows,cols,matrix,i,j):
        count=0
        if 0<=i<rows and 0<=j<cols and self.judge(threshold,i,j) and matrix[i][j]==0:
            matrix[i][j]=1
            count=1+self.findgrid(threshold,rows,cols,matrix,i+1,j)+self.findgrid(threshold,rows,cols,matrix,i-1,j)+self.findgrid(threshold,rows,cols,matrix,i,j-1)+self.findgrid(threshold,rows,cols,matrix,i,j+1)
        return count