题目描述：
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
思路：
这里用了一个数组reverse，但是实际可以用递归
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 返回从尾部到头部的列表值序列，例如[1,2,3]
def printListFromTailToHead(self, listNode):
l = []
while listNode:
l.append(listNode.val)
listNode = listNode.next
l.reverse()
return l
题目描述：
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：
因为是树的结构，一般都是用递归来实现。
用数学归纳法的思想就是，假设最后一步，就是root的左右子树都已经重建好了，那么我只要考虑将root的左右子树安上去即可。
根据前序遍历的性质，第一个元素必然就是root，那么下面的工作就是如何确定root的左右子树的范围。
根据中序遍历的性质，root元素前面都是root的左子树，后面都是root的右子树。那么我们只要找到中序遍历中root的位置，就可以确定好左右子树的范围。
正如上面所说，只需要将确定的左右子树安到root上即可。递归要注意出口，假设最后只有一个元素了，那么就要返回。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def reConstructBinaryTree(self, pre, tin):
# 递归终止条件
if not pre and not tin:
return
# 树的根结点
root = TreeNode(pre[0])
# 根结点在中序遍历中的位置
i = tin.index(pre[0])
root.left = self.reConstructBinaryTree(pre[1:i+1], tin[:i])
root.right = self.reConstructBinaryTree(pre[i+1:], tin[i+1:])
return root
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
stack1输出给stack2，2一有就输出pop
# -*- coding:utf-8 -*-
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==[]:
# stack1一旦装了就输出
while self.stack1:
self.stack2.append(self.stack1.pop())
# 这里递归回来确保stack1 stack2是空的
return self.stack2.pop()
# 递归回来立刻输出
return self.stack2.pop()
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
思路：
背
# -*- coding:utf-8 -*-
class Solution:
def Fibonacci(self, n):
# write code here
if n == 0:
return 0
if n == 1:
return 1
if n == 2:
return 1
if n >= 3:
s = []*n
s.append(1)
s.append(1)
for i in xrange(2,n):
s.append(s[i-1]+s[i-2])
return s[n-1]
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
思路：
无论你跳多少，都是从1 2 层上去的
本质上是一个斐波那契数据
f(n) = f(n-1)+f(n-2)
# -*- coding:utf-8 -*-
class Solution:
def jumpFloor(self,number):
# write code here
if (number <= 0) :
return 0
if (number == 1) :
return 1
if (number == 2) :
return 2
first = 1
second = 2
third = 0
for i in range(3,number+1):
third = first + second
first = second
second = third
return third
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路：
得出最终结论,在n阶台阶，一次有1、2、...n阶的跳的方式时，总得跳法为：
| 1 ,(n=0 )
f(n) = | 1 ,(n=1 )
| 2*f(n-1),(n>=2)
（可以理解为最后一块板的选择是两种，踩或者不踩）
# -*- coding:utf-8 -*-
import math
class Solution:
def jumpFloorII(self, number):
# write code here
if number <= 0:
return 0
else:
number = number - 1
return math.pow(2,number)
# write code here
题目描述
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
比如n=3时，2*3的矩形块有3种覆盖方法：
我的思路，按着这个方式可以的，但是上面运行不通过，没搞懂
# -*- coding:utf-8 -*-
class Solution:
def rectCover(self, number):
# write code here
if number <1:
return 0
elif number <=3:
return number
else:
number = self.rectCover(number-1)+self.rectCover(number-2)
return number
别人做法：
# -*- coding:utf-8 -*-
class Solution:
def rectCover(self, number):
# write code here
if number < 1:
return 0
p = q = r =0
for i in range(1,number+1):
if i == 1:
p = q = r =1
elif i == 2:
q = r = 2
else:
r = q + p
p = q
q = r
return r
题目描述
输入一个链表，输出该链表中倒数第k个结点。
思路：
用一个数组装着，倒数K个，用的list[-k]
# -*- 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
l=[]
while head!=None:
l.append(head)
head=head.next
if k>len(l) or k<1:
return
return l[-k]
题目描述
输入一个链表，反转链表后，输出新链表的表头。
思路：
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 返回ListNode
def ReverseList(self, pHead):
# write code here
if pHead is None:
return pHead
last = None #指向上一个节点
while pHead:
# 先用tmp保存pHead的下一个节点的信息，
# 保证单链表不会因为失去pHead节点的next而就此断裂
tmp = pHead.next
# 保存完next，就可以让pHead的next指向last了
pHead.next = last
# 让last，pHead依次向后移动一个节点，继续下一次的指针反转
last = pHead
pHead = tmp
return last
题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
思路：
就是另外生成一个链表去匹配
# -*- 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
mergeHead = ListNode(90)
# 这里是把头指针给了p
p = mergeHead
while pHead1 and pHead2:
if pHead1.val >= pHead2.val:
mergeHead.next = pHead2
pHead2 = pHead2.next
else:
mergeHead.next = pHead1
pHead1 = pHead1.next
mergeHead = mergeHead.next
# 看看1和2哪个还没走完的
if pHead1:
mergeHead.next = pHead1
elif pHead2:
mergeHead.next = pHead2
return p.next
题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：
递归下去，到最后一个结点
链接：https://www.nowcoder.com/questionTerminal/6e196c44c7004d15b1610b9afca8bd88
来源：牛客网
public class Solution {
public static boolean HasSubtree(TreeNode root1, TreeNode root2) {
boolean result = false;
//当Tree1和Tree2都不为零的时候，才进行比较。否则直接返回false
if (root2 != null && root1 != null) {
//如果找到了对应Tree2的根节点的点
if(root1.val == root2.val){
//以这个根节点为为起点判断是否包含Tree2
result = doesTree1HaveTree2(root1,root2);
}
//如果找不到，那么就再去root的左儿子当作起点，去判断时候包含Tree2
if (!result) {
result = HasSubtree(root1.left,root2);
}
//如果还找不到，那么就再去root的右儿子当作起点，去判断时候包含Tree2
if (!result) {
result = HasSubtree(root1.right,root2);
}
}
//返回结果
return result;
}
public static boolean doesTree1HaveTree2(TreeNode node1, TreeNode node2) {
//如果Tree2已经遍历完了都能对应的上，返回true
if (node2 == null) {
return true;
}
//如果Tree2还没有遍历完，Tree1却遍历完了。返回false
if (node1 == null) {
return false;
}
//如果其中有一个点没有对应上，返回false
if (node1.val != node2.val) {
return false;
}
//如果根节点对应的上，那么就分别去子节点里面匹配
return doesTree1HaveTree2(node1.left,node2.left) && doesTree1HaveTree2(node1.right,node2.right);
}
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
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)
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。
思路：
用一个栈data保存数据，用另外一个栈min保存依次入栈最小的数
比如，data中依次入栈，5, 4, 3, 8, 10, 11, 12, 1
则min依次入栈，5, 4, 3，no,no, no, no, 1
no代表此次不如栈
每次入栈的时候，如果入栈的元素比min中的栈顶元素小或等于则入栈，否则不如栈。
# -*- 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(not self.min_stack or node <= self.min_stack[-1]):
self.min_stack.append(node)
def pop(self):
# write code here
if(self.stack[-1] == self.min_stack[-1]):
self.min_stack.pop()
return self.stack.pop()
def top(self):
# write code here
return self.stack[-1]
def min(self):
# write code here
return self.min_stack[-1]
题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：
递归
def PrintFromTopToBottom(self, root):
if not root:
return []
currentStack = [root]
res = []
while currentStack:
nextStack = []
for i in currentStack:
if i.left: nextStack.append(i.left)
if i.right: nextStack.append(i.right)
res.append(i.val)
currentStack = nextStack
return res
题目描述
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
#前序
def preorder(self,root,ans=[]):
if root!=None:
ans.append(root.val)
if root.left:
self.preorder(root.left,ans)
if root.right:
self.preorder(root.right,ans)
return ans
#中序
def inorder(self,root,ans=[]):
# if root.left==None and root.right==None:
# ans.append(root.val)
# return
if root.left:
self.inorder(root.left,ans)
ans.append(root.val)
if root.right:
self.inorder(root.right,ans)
return ans
#后序
def postorder(self,root,ans=[]):
if root.left:
self.postorder(root.left,ans)
if root.right:
self.postorder(root.right,ans)
ans.append(root.val)
return ans
题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路：
把左子树、右子树的状态都设置为布尔值，递归两边，判断是不是都符合左小右大的规则
python:后序遍历 的序列中，最后一个数字是树的根节点 ，数组中前面的数字可以分为两部分：第一部分是左子树节点 的值，都比根节点的值小；第二部分 是右子树 节点的值，都比 根 节点 的值大，后面用递归分别判断前后两部分 是否 符合以上原则
class Solution:
def VerifySquenceOfBST(self, sequence):
# write code here
if sequence==None or len(sequence)==0:
return False
length=len(sequence)
root=sequence[length-1]
# 在二叉搜索 树中 左子树节点小于根节点
for i in range(length):
if sequence[i]>root:
break
# 二叉搜索树中右子树的节点都大于根节点
for j in range(i,length):
if sequence[j]<root:
return False
# 判断左子树是否为二叉树
left=True
if i>0:
left=self.VerifySquenceOfBST(sequence[0:i])
# 判断 右子树是否为二叉树
right=True
if i<length-1:
right=self.VerifySquenceOfBST(sequence[i:-1])
return left and right
题目描述
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
思路：
排列组合常用工具
import itertools
itertools.permutations（str）
# -*- coding:utf-8 -*-
import itertools
class Solution:
def Permutation(self, ss):
# write code here
if not ss:
return ss
result = []
k = itertools.permutations(ss)
for i in k:
result.append(‘‘.join(i))
result = list(set(result))
# 一定要排序才能过
result.sort()
return result
题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
最简单的题，卡进了莫名的BUG。。不能全部AC
# -*- coding:utf-8 -*-
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
if tinput is None:
return
n = len(tinput)
if n < k:
return []
tinput = sorted(tinput)
return tinput[:k]
题目描述
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
思路：
掌握str.count(i) 可以查找字符串中元素个数
# -*- coding:utf-8 -*-
class Solution:
def NumberOf1Between1AndN_Solution(self, n):
# write code here
a = 0
for i in range(0, n+1):
if (‘1‘ in str(i)):
ind = str(i).count(‘1‘)
a+= ind
else:
pass
return a
题目描述
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
# -*- coding:utf-8 -*-
class Solution:
def PrintMinNumber(self, numbers):
# write code here
temp = [str(x) for x in sorted(numbers, cmp=self.f_cmp)]
return ‘‘.join(temp)
def f_cmp(self,a,b):
if str(a)+str(b) < str(b)+str(a):
return -1
elif str(a)+str(b) > str(b)+str(a):
return 1
else:
return 0
题目描述
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
# -*- coding:utf-8 -*-
class Solution():
def FirstNotRepeatingChar(self, s):
dict_n = {}
simple_list = []
for i in s:
if(i not in dict_n):
dict_n[i] = 1
else:
dict_n[i]+=1
for i in dict_n:
if(dict_n[i]==1):
simple_list.append(i)
start_pos = []
if(len(simple_list)):
for j in simple_list:
ind = s.index(j)
start_pos.append(ind)
start_pos.sort()
return start_pos[0]
else:
return -1
题目描述
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
思路：
通过结点的值相同，确定这个就是公共节点，返回node即可
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def FindFirstCommonNode(self, head1, head2):
# write code here
list1 = []
list2 = []
node1 = head1
node2 = head2
while node1:
list1.append(node1.val)
node1 = node1.next
while node2:
if node2.val in list1:
return node2
else:
node2 = node2.next
题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路：
其实就是深度遍历，用递归的方法可以了。递归求解：
假如是空节点，则返回0；
否则，原树的深度由左右子树中深度较的深度加1，为原树的深度。
# -*- 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
if not pRoot:
return 0
return max(1 + self.TreeDepth(pRoot.left), 1 + self.TreeDepth(pRoot.right))
题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
思路：先判断两棵树的最深高度是多少，如果一样就继续，一层层递归下去，确保每一颗子树都一样
# -*- 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
# 如果两边的树不是一样高，就不是平衡树
a = abs(self.TreeDepth(pRoot.left) - self.TreeDepth(pRoot.right))
if(a>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_ = 1 + self.TreeDepth(pRoot.left)
right_ = 1 + self.TreeDepth(pRoot.right)
return max(left_, right_)
题目描述
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出.
# -*- coding:utf-8 -*-
import itertools
class Solution:
def FindNumbersWithSum(self, array, tsum):
if(array.__len__()==0):
return array
tsum_list =[]
dix_ = 0
result = []
for i in itertools.permutations(array,2):
if(i[0]+i[1]==tsum):
tsum_list.append(i)
for i in tsum_list:
if(dix_==0):
dix_ = i[0] * i[1]
result = [min(i[0], i[1]), max(i[0], i[1])]
elif(i[0]*i[1]<dix_):
dix_ = i[0]*i[1]
result = [min(i[0],i[1]),max(i[0],i[1])]
return result
题目描述
对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
思路：采用序列拼接，机智！
# -*- coding:utf-8 -*-
class Solution:
def LeftRotateString(self, s, n):
# write code here
return s[n:]+s[:n]
题目描述
字符串翻转思路
注意，用reverse,lst[::-1]都可以
# -*- coding:utf-8 -*-
class Solution:
def ReverseSentence(self, s):
# write code here
l=s.split(‘ ‘)
return ‘ ‘.join(l[::-1])
题目描述
求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
思路：不能用循环，那就递归解决吧！
# -*- coding:utf-8 -*-
class Solution:
def __init__(self):
self.a = 0
def Sum_Solution(self, n):
if n==0:
return self.a
else:
self.a += n
return self.Sum_Solution(n-1)
题目描述
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
思路：本意是想让我们掌握01计算
public class Solution {
public int Add(int num1,int num2) {
while (num2!=0) {
int temp = num1^num2;
num2 = (num1&num2)<<1;
num1 = temp;
}
return num1;
}
}
原文地址：https://www.cnblogs.com/tfknight/p/12628143.html