1. 二维数组的查找
题目：在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
# -*- coding:utf-8 -*-
class Solution:
# array 二维列表
def Find(self, target, array):
# write code here
if len(array)==0 or len(array[0])==0:#len(array)==0是判断列表的行数是否是0，len(array[0])是判断列表的列数是否为0
return False
i = 0
j = len(array[0])-1
while(i<len(array) and j>=0):
if array[i][j]==target:
return True
elif array[i][j]>target:
j-=1
else:
i+=1
return False2. 替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
# -*- coding:utf-8 -*-
import re
class Solution: # s 源字符串
def replaceSpace(self, s):
# write code here
return re.sub(' ',"%20",s)3. 从头到尾打印链表
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
# -*- 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
ret=[]
head=listNode
while(head):
ret.append(head.val)
head=head.next
ret.reverse()
return ret 4. 重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
具体讲解见：https://blog.csdn.net/songyunli1111/article/details/80138757
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 len(pre)==0:
return None
root=TreeNode(pre[0])
TinIndex=tin.index(pre[0])
root.left=self.reConstructBinaryTree(pre[1:TinIndex+1], tin[0:TinIndex])
root.right=self.reConstructBinaryTree(pre[TinIndex+1:], tin[TinIndex+1:])
return root
def PostTraversal(self,root): #后序遍历
if root != None:
self.PostTraversal(root.left)
self.PostTraversal(root.right)
print(root.val)5. 用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：对栈1一直添加元素。当栈2非空时，将栈2中的元素弹出，再由栈2添加元素；否则，栈1将会一直弹出元素给栈2。
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 len(self.stack2):
return self.stack2.pop()
while(self.stack1):
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。
class Solution:
def minNumberInRotateArray(self, rotateArray):
# write code here
if rotateArray == []:
return 0
_len = len(rotateArray)
left = 0
right = _len - 1
while left <= right:
mid = int((left + right) >> 1)
if rotateArray[mid]<rotateArray[mid-1]:
return rotateArray[mid]
if rotateArray[mid] >= rotateArray[right]:
# 说明在【mid，right】之间
left = mid + 1
else:
# 说明在【left，mid】之间
right = mid - 1
return rotateArray[mid]
#由最终的测试例子[6501,6828,6963,7036,7422,7674,8146,8468,8704,8717,9170,9359,9719,9895,9896,9913,9962,
#154,293,334,492,1323,1479,1539,1727,1870,1943,2383,2392,2996,3282,3812,3903,4465,4605,4665,4772,4828,
#5142,5437,5448,5668,5706,5725,6300,6335]
#可以知道，列表是前一部分（不一定是正中间）是单调增加的，后一部分是单调增加的，但是整体不是单调增加的特殊列表。
#测试例子，输出是1
#A1=[3,4,5,1，2]
#测试例子，输出是5
#A1=[3,4,7,8,10,4,6,5,9,6]
#S=Solution()
#inverseA1=S.minNumberInRotateArray(A1)
#print(inverseA1)7. 斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
# -*- coding:utf-8 -*-
class Solution:
def Fibonacci(self, n):
if n == 0:
return 0
if n==1 or n==2:
return 1
memories = [1,1]
for i in range(n-2):
memories.append(memories[-1]+memories[-2])
return memories[-1]
#分析：memories = [1,1]，则memories[-1]+memories[-2]=2。当n=7时，i=0,...,4。
#对应的memories[-1]和memories[-2]也发生改变，依次是1、2；2、3；3、5；5、8；8、13,
#因而输出memories[-1]为13。
#arraySolution=Solution()
#print(arraySolution.Fibonacci(7))8. 跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
# -*- coding:utf-8 -*-
class Solution:
def jumpFloor(self, number):
# write code here
'''
n = 1 : 1
n = 2 : 1+1 = 2
n = 3 : dp[n-2]+dp[n-1]
'''
if number == 1 or number == 2:
return number
dp = [1,2]
for i in range(number-2):
dp.append(dp[-1]+dp[-2])
return dp[-1]
#例如n=number=4，则有i=0,1。对应的dp为2、3;3、5，最终输出dp[-1]为5。
#steps=Solution()
#print(steps.jumpFloor(4))9. 变态跳台阶
class Solution:
def jumpFloorII(self, number):
# write code here
if number == 1 or number == 2:
return number
ret = sum_ = 3
for i in range(number-2):
ret = sum_+1
sum_+=ret
return ret
#结果是C^1_{n}+C^2_{n}+...+C^n_{n}=2^n-1。若令n=number=4，则对于n=2而言，有
#结果为3。i=0，有3+4=7；i=1，有7+8=15,即为上述编程思路。10. 矩阵覆盖
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
class Solution:
def rectCover(self, number):
# write code here
if number<=2:
return number
dp = [1,2]
for i in range(number-2):
dp.append(dp[-1]+dp[-2])
return dp[-1]
#类似于之前的对7、8和9的分析，即矩形的长度方向的每步只能增加1或者2，当确定是1或者2时
#对应的纵轴的每步大小也是可以确定的。11. 二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路：当n是负数的时候，由于右移时最高位是补1的，因而为了能够利用while进行循环，需要对对高位取0，并在此次操作之后将res加1以表示有一位是1。对于while循环来说，res返回的即为有1的位数的个数。
class Solution:
def NumberOf1(self, n):
# write code here
ans = 0
if n<0:
n = n & 0x7fffffff
ans+=1
while n:
ans += n & 1
n >>= 1
return ans 12. 数值的正数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
思路：这里无须对base等于0进行说明。
class Solution:
def Power(self, base, exponent):
if exponent==0:
return 1;
exp=abs(exponent)
ans=1.0
for i in range(0,exp):
ans=ans*base
if exponent>0:
return ans;
else :
return 1/ans13. 调整数组中元素的位置，使得奇数在偶数的前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
class Solution:
def reOrderArray(self, array):
size = len(array)
pos = size-1
cnt = 0
while(cnt<size):
if array[pos]%2==1:
tmp = array[pos]
for i in range(pos-1,-1,-1):
array[i+1] = array[i]
array[0] = tmp
else:
pos -=1
cnt +=1
return array
#下面是测试例子，输出是[7,1,3,5,6,10]
#array1=Solution()
#array2=[6,7,10,1,3,5]
#b=array1.reOrderArray(array2)
#print(b)14. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个结点。
思路1：正常思路，先遍历链表找到链表的长度，之后找到链表中的第n-k+1个节点即为所求。
思路2：设置两个指针p1和p2，当p1到达链表的最后一个节点时，与之相隔k-1个节点的节点即为所求。
# -*- 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
if head == None or k <= 0:
return None
p1 = head
p2 = head
for i in range(k-1):
if p1.next == None:
return None
p1 = p1.next #i从0到k-2，对应的p1指向第k+1个节点。
while p1.next != None:
p1 = p1.next
p2 = p2.next
return p215. 反转链表
输入一个链表，反转链表后，输出新链表的表头。
参考：反转链表的三种方法：https://blog.csdn.net/The__Apollo/article/details/78769400
Python代码示例：https://www.jb51.net/article/134706.htm
看图理解单链表的反转：https://blog.csdn.net/feliciafay/article/details/6841115
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
ret = ListNode(0)
tmp = ret
p1 = pHead1
p2 = pHead2
while(p1 and p2):
if p1.val<p2.val:
tmp.next = ListNode(p1.val)
p1 = p1.next
else:
tmp.next = ListNode(p2.val)
p2 = p2.next
tmp = tmp.next
if p1:
tmp.next = p1
if p2:
tmp.next = p2
return ret.next17. 树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
疑问：为何两个子树都为空时，输出既有True，又有False。
class Solution:
def HasSubtree(self, pRoot1, pRoot2):
def subtree(pRoot1,pRoot2):
if pRoot2 == None and pRoot1 == None:
return True
if pRoot2 == None:
return False
if pRoot1 == None:
return False
if pRoot2.val == pRoot1.val:
if pRoot2.left == None and pRoot2.right == None:
return True
if subtree(pRoot1.left,pRoot2.left) and subtree(pRoot1.right,pRoot2.right):
return True
return subtree(pRoot1.left,pRoot2) or subtree(pRoot1.right,pRoot2)
if pRoot1 == None and pRoot2 == None:
return False
return subtree(pRoot1,pRoot2)18. 二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
class Solution:
def Mirror(self, root):
# write code here
if not root:
return None
left, right = root.left, root.right
root.left = right
root.right = left
self.Mirror(root.left)
self.Mirror(root.right)
return root19. 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 * 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.
思路：m和n分别表示矩阵的行数和列数。在顺时针依次打印时，有以下四步：
1）i不变，j++，设置变量upper_i自加1使得下次循环的i减小时，下限是上次循环中的数值upper_i+1；
2）j不变，i--，设置变量right_j自减1使得下次循环的j增加时，上限是上次循环中的数值right_j-1；
3）i不变，j--，设置变量lower_i自减1使得下次循环的i增加时，上限是上次循环中的数值lower_i-1；
4) j不变，i++，设置变量left_j自加1使得下次循环的j减小时，下限是上次循环中的数值left_j+1。
class Solution:
# matrix类型为二维列表，需要返回列表
def printMatrix(self, matrix):
# write code here
m=len(matrix)
ans=[]
if m==0:
return ans
n=len(matrix[0])
#ans = [[0 for i in range(n)] for j in range(n)]
#print ans
upper_i =0;lower_i=m-1;left_j=0;right_j=n-1
num=1
i=0;j=0
right_pointer=1
down_pointer=0
while(num<=m*n):
ans.append(matrix[i][j])
if right_pointer==1:
if j<right_j:
j=j+1
else:
right_pointer=0
down_pointer=1
upper_i = upper_i+1
i = i+1
elif down_pointer == 1:
if i<lower_i:
i = i+1
else:
right_pointer=-1
down_pointer=0
right_j = right_j -1
j = j-1
elif right_pointer ==-1:
if j > left_j:
j=j-1
else:
right_pointer=0
down_pointer=-1
lower_i =lower_i-1
i = i-1
elif down_pointer == -1:
if i > upper_i:
i=i-1
else:
right_pointer=1
down_pointer=0
left_j = left_j +1
j = j+1
num=num+1
return ans20. 包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
思路：比较新压入的数值与之前压入的数值进行比较，若比之前的小，则压入最小值；否则压入之前的最小值。[-1]表示最上面的数值即为最小值。这里引入辅助矩阵，帮存储最小值。
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:
temp = self.min()
self.min_stack.append(temp)
def pop(self):
# 只要不为空就删除原始栈和辅助栈的元素
if self.min_stack == [] or self.stack == []:
return None
self.min_stack.pop()
self.stack.pop()
def top(self):#返回栈顶
# write code here
return self.stack[-1]
def min(self):
# 返回当前最小值
return self.min_stack[-1]21. 栈的压入和弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）。
思路：设置一个辅助栈stack，用来存储从pushV中弹出的数据。首先判断pop和push中的第一个元素是否相等，如果相等的话，就将它们依次弹出；如果不相等的话，就一直向stack中压入数据，比较stack中的最后一个数据与popV中的最顶端数据是否相等，如果相等的话则将其分别弹出，否则的话依然继续压入数据。
# -*- coding:utf-8 -*-
class Solution:
def IsPopOrder(self, pushV, popV):
# stack中存入pushV中取出的数据
stack=[]
while popV:
# 如果第一个元素相等，直接都弹出，根本不用压入stack
if pushV and popV[0]==pushV[0]:
popV.pop(0)
pushV.pop(0)
#如果stack的最后一个元素与popV中第一个元素相等，将两个元素都弹出
elif stack and stack[-1]==popV[0]:
stack.pop()
popV.pop(0)
# 如果pushV中有数据，压入stack
elif pushV:
stack.append(pushV.pop(0))
# 上面情况都不满足，直接返回false。
else:
return False
return True22. 从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
其中，当i,j都缺省时，tbfs[:]就相当于完整复制一份tbfs了，即也可以写作bfs=tbfs。
# -*- 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
ret = []
if root == None:
return ret
bfs = [root]
while(bfs):
tbfs = []
for node in bfs:
ret.append(node.val)
if node.left:
tbfs.append(node.left)
if node.right:
tbfs.append(node.right)
bfs = tbfs[:]
return ret