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
这里我遇到了一个小问题，试了几次都不知道如何判断列表为空，百度了以后才知道可以用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.合并两个排序的链表
题目描述：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则
思路：
- 从根节点开始，判断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)
17.树的子结构
题目描述：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：
代码如下：
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
if len(sequence)==0:return False
l=len(sequence)
index=l-2
#如果下面的循环中没有改变index的值，那么就相当于右子树为空，所以后面只需要对左子树进行迭代。
for i in range(l):
if sequence[i]>sequence[-1]:
index=i
break
for j in range(i,l):
if sequence[j]<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。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
思路：
代码如下：
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出现的次数）
题目描述：求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
思路：
代码如下：
32.把数组排成最小的数
题目描述：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
思路：
代码如下：
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
思路：
代码如下：
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.平衡二叉树
题目描述：输入一棵二叉树，判断该二叉树是否是平衡二叉树。
思路：
代码如下：
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，搞定它！
思路：
代码如下：
44.翻转单词顺序列
题目描述：牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
思路：
代码如下：
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。
思路：
代码如下：
46.孩子们的游戏（圆圈中最后剩下的数）
题目描述：每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
思路：
代码如下：
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)))
48.不用加减乘除做加法
题目描述：写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
思路：我的想法还是用python的内置函数sum，简单粗暴
代码如下：
class Solution:
def Add(self, num1, num2):
# write code here
return sum([num1,num2])
49.把字符串转换成整数
题目描述：将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
思路：
代码如下：
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]。不能使用除法。
思路：
代码如下：
52.正则表达式匹配
题目描述：请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配
思路：
代码如下：
53.表示数值的字符串
题目描述：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
思路：
代码如下：
54.字符流中第一个不重复的字符
题目描述：请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
思路：
代码如下：
55.链表中环的入口结点
题目描述：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
思路：
代码如下：
56.删除链表中的重复的结点
题目描述：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路：
代码如下：
57.二叉树的下一个结点
题目描述：给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路：
代码如下：
58.对称的二叉树
题目描述：请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
思路：
代码如下：
59.按之字形顺序打印二叉树
题目描述：请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
思路：
代码如下：
60.把二叉树打印成多行
题目描述：从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
思路：
代码如下：
61.序列化二叉树
题目描述：请实现两个函数，分别用来序列化和反序列化二叉树
思路：
代码如下：
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 k<=0:
return None
res=[]
self.midnode(pRoot,res)
if len(res)<k:
return None
return res[k-1]
def midnode(self,root,res):
if not root:
return None
if root.left:
self.midnode(root.left,res)
res.append(root)
if root.right:
self.midnode(root.right,res)
63.数据流中的中位数
题目描述：如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
思路：
代码如下：
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]}。
思路：
代码如下：
65.矩阵中的路径
题目描述：请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
思路：
代码如下：
66.机器人的运动范围
题目描述：地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
思路：
代码描述：