1.打印一个链表，从尾到头打印链表
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 返回从尾部到头部的列表值序列，例如[1,2,3]
def printListFromTailToHead(self, listNode):
# write code here
cur = listNode
l=list() # l=[]
while cur:
l.append(cur.val)
cur=cur.next
return l[::-1]
2、用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型
思路：两个栈S1，S2，分别作为存储区和缓冲区
入队时，将元素压入s1。
出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1。
见下面示意图：
# -*- 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): if self.stack2 ==[]: while self.stack1: self.stack2.append(self.stack1.pop()) return self.stack2.pop() # return xx
3 .找数组中的最小数
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路：循环len(array)-1次，采用冒泡排序的思想，比较array[i]与array[i+1]的大小，如果前者比后者小，就后移，循环完成后最末尾的数值就是此序列的最小值
x# -*- coding:utf-8 -*- class Solution: def minNumberInRotateArray(self, rotateArray): # write code here n = len(rotateArray) if n>=1: for i in range(0,n-1): if rotateArray[i]<rotateArray[i+1]: rotateArray[i],rotateArray[i+1]=rotateArray[i+1],rotateArray[i] return rotateArray.pop() else: return 0
4.二维数组查找目标
描述：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
# -*- coding:utf-8 -*- class Solution: # array 二维列表 def Find(self, target, array): # write code here rows = len(array) - 1 cols= len(array[0]) - 1 i = rows j = 0 while j<=cols and i>=0: if target<array[i][j]: i -= 1 elif target>array[i][j]: j += 1 else: return True return False
5. 斐波那契数列
裴波那数列：f(0) = 1,f(1) = 1,f(n) = f(n-1) + f(n-2)
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39
# -*- coding:utf-8 -*-
class Solution:
def __init__(self):
self.lists=[0,1]
def Fibonacci(self, n):
# write code here
if n==0:
return 0
elif n==1:
return 1
elif n>1:
count =n
while count-1>0:
lens=len(self.lists)
self.lists.append(self.lists[lens-1]+self.lists[lens-2])
count-=1
return self.lists[n]
6. 跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路：如果第一步跳1阶，那么还剩下f(n-1)；如果第一步跳2阶，那么还剩下f(n-2);f(1)=1,f(2)=2,就是递归的裴波那契数列
改进了上一个裴波那契数列的代码
class Solution:
def jumpFloor(self, number):
# write code here
a=[1,2]
if number==1:
return 1
elif number==2:
return 2
elif number>2:
for i in range(2,number):
a.append(a[i-1]+a[i-2])
return a[number-1]
或者不记录前n项，直接求第n项
class Solution:
def jumpFloor(self, number):
# write code here
a = 1
b = 1
for i in range(number):
a,b = b,a+b
return a
6. 变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法
思路： Fib(n) = Fib(n-1)+Fib(n-2)+Fib(n-3)+..........+Fib(n-n)=Fib(0)+Fib(1)+Fib(2)+.......+Fib(n-1)
又因为Fib(n-1)=Fib(0)+Fib(1)+Fib(2)+.......+Fib(n-2)
两式相减得：Fib(n)-Fib(n-1)=Fib(n-1) =====》 Fib(n) = 2*Fib(n-1) n >= 2
递归等式如下：
class Solution:
def jumpFloorII(self, number):
# write code here
return 2**(number-1)
7. 打印链表中倒数第k个节点
思路：先求出链表的长度n，倒数第k个即顺数n-k个，通过循环n-k次就可以找到此节点
需要考虑两个特殊情况：k大于n或小于等于0；链表是空链表。
还有一个问题就是头结点，链表和栈以及二叉树都是整体赋值过去，并没有头结点属性
（1）对于空链表，返回链表本身
（2）当k大于n，返回链表末尾的值
（3）当n大于k，则循环n-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
n = self.length(head)
if n==0:
return head
index = n-k
cur = head
if index<0:
for i in range(n):
cur = cur.next
return cur
else:
for i in range(index):
cur = cur.next
return cur
def length(self,head):
cur =head
count = 0
while cur:
cur = cur.next
count = count+1
return count
看到一个网友超简便的方法，新建一个list反存原链表，再通过索引直接取出来。此处的list就是一个顺序表
8、栈的压入和弹出
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
注意：没好好省题，并不是存完再取出来，可以边存边弹出，再存再弹出
思路：新建一个缓存区，放入入栈元素，并与出栈最后一个判断，相等就剔除，不等就压栈存入下一个元素再判断，直到缓存区为空
class Solution:
def IsPopOrder(self, pushV, popV):
if not pushV or len(pushV)!=len(popV):
return 0
stack=[]
for i in pushV:
stack.append(i)
while len(stack) and stack[-1]==popV[0]:
stack.pop()
popV.pop(0)
if len(stack):
return 0
return 1
9、输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路：找到大的树，依次循环结点去比对小子树的跟结点，直到相同。
正确的是：递归循环