剑指OFFER（持续更新中...)
基本用python,涉及到栈，链表，二叉树，数组，字符串
python中的类中属性元素加self.和不加self.的区别：
如果不加self，表示是类的一个属性（可以通过“类名.变量名”的方式引用），加了表示是类的实例的一个属性（可以通过“实例名.变量名”的方式引用）。
1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
简单：遍历操作
# -*- coding:utf-8 -*-
class Solution:# array 二维列表def Find(self, target, array):# write code hererow=len(array)col=len(array[0])for i in range(row):for j in range(col):if array[i][j]==target:return Truereturn False高效：矩阵是有序的，从左下角元素来看，往右数字递增，往上数字递减。因此从左下角开始找，如果target比左下角元素大，向右移，否则，向左移。
2.请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
# -*- coding:utf-8-*-
classSolution:# s 源字符串def replaceSpace(self, s):return s.replace(' ','%20') 3.输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
# 1.先遍历链表元素到栈
# 2.栈再弹出
class Solution:# 返回从尾部到头部的列表值序列，例如[1,2,3]def printListFromTailToHead(self, listNode):# write code herelst,lst_bak = [],[]if not listNode:return lstwhile listNode:lst.append(listNode.val)listNode = listNode.nextwhile lst:lst_bak.append(lst.pop())return lst_bak注意：pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
4.输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
# -*- coding:utf-8 -*-
# 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 hereif not pre or not tin:return Noneroot = TreeNode(pre.pop(0))index = tin.index(root.val)root.left = self.reConstructBinaryTree(pre, tin[:index])root.right = self.reConstructBinaryTree(pre, tin[index + 1:])return root5.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
入队：将元素进栈1
出队：判断栈2是否为空，如果为空，则将栈1中所有元素pop，并push进栈B，栈B出栈；如果不为空，栈2直接出栈。
# -*- coding:utf-8 -*-
class Solution:def __init__(self):self.stack1 = []self.stack2 = []def push(self, node):# write code hereself.stack1.append(node)def pop(self):# return xxif len(self.stack2) > 0:return self.stack2.pop()while self.stack1:self.stack2.append(self.stack1.pop())if len(self.stack2) > 0:return self.stack2.pop()6.把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
# -*- coding:utf-8 -*-
class Solution:def minNumberInRotateArray(self, rotateArray):# write code herereturn min(rotateArray)注：这个题可能有问题了。。
7.大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
# -*- coding:utf-8 -*-
class Solution:def Fibonacci(self, n):# write code hereres=[0,1]while len(res)<=n:res.append(res[-1]+res[-2])return res[n]大话数据结构102页。斐波那契数列：0，1，1，2，3，5，8..... F(n)=F(n-1)+F(n-2)
8.一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
设跳第n级台阶的跳法种数为f(n)，f(1) = 1, f(2) = 2, f(3) = 3, f(4) = 5， 可以总结出f(n) = f(n-1) + f(n-2)的规律
# -*- coding:utf-8 -*-
class Solution:def jumpFloor(self, number):# write code hereres=[1,1,2]while len(res)<=number:res.append(res[-1]+res[-2])return res[number]9.一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
（1）假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1)；假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)；假定第一次跳的是3阶，那么剩下的是n-3个台阶，跳法是f(n-3)......假定第一次跳的是n-1阶，那么剩下的是1个台阶，跳法是f(1)； 假定第一次跳的是n阶，那么剩b下的是0个台阶，跳法是1种；
（2）总跳法为: f(n) = 1+f(n-1) + f(n-2)+....+f(1) （第一个1是跳n阶只有一种方法）
（3）根据（2）可以得出有一阶的时候 f(1) = 1 ；有两阶的时候可以有 f(2) = 1+f(1)=2；有三阶的时候可以有 f(3) = 1+f(2)+f(1)=4...依次内推，有n阶时f(n)=2^(n-1)。
# -*- coding:utf-8 -*-
class Solution:def jumpFloorII(self, number):# write code herereturn 2**(number-1)10.我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？递推关系式为f(n) = f(n-1) + f(n-2)， (n > 2)
# -*- coding:utf-8 -*-
class Solution:def rectCover(self, number):# write code hereres=[0,1,2]while len(res) <= number:res.append(res[-1] + res[-2])return res[number]11.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
解法：如果n大于0，直接计算即可，如果n小于0，计算2的32次方加上n的结果中1的个数。记住吧，我也不明白
# -*- coding:utf-8 -*-
class Solution:def NumberOf1(self, n):# write code herereturn bin(n).replace("0b","").count("1") if n>=0 else bin(2**32+n).replace("0b","").count("1")注：bin() 返回一个整数 int 或者长整数 long int 的二进制表示。>bin(10)>> '0b1010'
- 正数原码就是其二进制。
- 负数的原码就是其二进制，并将最高位作为符号位设为1。
eg: -1 原码为：1000 0001- 负数进行运算时用补码表示：负数补码 = 负数原码不考虑最高符号位的原码的反码 + 1
eg： -1 的补码为：1111 1110（反码） +1 = 1111 1111
12.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
# -*- coding:utf-8 -*-
class Solution:def Power(self, base, exponent):# write code herereturn base**exponent13.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
odd代表奇数，even代表偶数
# -*- coding:utf-8 -*-
class Solution:def reOrderArray(self, array):# write code hereodd,even=[],[]for i in array:odd.append(i) if i%2==1 else even.append(i)return odd+even14.输入一个链表，输出该链表中倒数第k个结点。head代表结点，head.val代表结点的值
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = Noneclass Solution:def FindKthToTail(self, head, k):# write code hereres=[]while head:res.append(head)head=head.nextif k>len(res) or k<1:returnreturn res[-k]15.输入一个链表，反转链表后，输出新链表的表头。
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:# 返回ListNodedef ReverseList(self, pHead):# write code hereif not pHead or not pHead.next:return pHeadlast = Nonewhile pHead:tmp = pHead.next pHead.next = lastlast = pHeadpHead = tmpreturn last16.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:# 返回合并后列表def Merge(self, pHead1, pHead2):# write code heredummy = ListNode(0)pHead = dummywhile pHead1 and pHead2:if pHead1.val >= pHead2.val:dummy.next = pHead2pHead2 = pHead2.nextelse:dummy.next = pHead1pHead1 = pHead1.nextdummy = dummy.nextif pHead1:dummy.next = pHead1elif pHead2:dummy.next = pHead2return pHead.next17.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:def HasSubtree(self, pRoot1, pRoot2):# write code heredef convert(p):if p:return str(p.val) + convert(p.left) + convert(p.right)else:return ""return convert(pRoot2) in convert(pRoot1) if pRoot2 else False18.操作给定的二叉树，将其变换为源二叉树的镜像。
# self.val = x
# self.left = None
# self.right = None
class Solution:# 返回镜像树的根节点def Mirror(self, root):# write code hereif not root:return rootnode=root.leftroot.left=root.rightroot.right=nodeself.Mirror(root.left)self.Mirror(root.right)return root19.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
# -*- coding:utf-8 -*-
class Solution:# matrix类型为二维列表，需要返回列表def printMatrix(self, matrix):# write code hereres = []while matrix:res += matrix.pop(0)if matrix and matrix[0]:for row in matrix:res.append(row.pop())if matrix:res += matrix.pop()[::-1]if matrix and matrix[0]:for row in matrix[::-1]:res.append(row.pop(0))return res注：pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。？？
27.输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
# -*- coding:utf-8 -*-
class Solution:def Permutation(self, ss):# write code hereif not ss:return []if len(ss) == 1:return [ss]ret = []#遍历字符串，固定第一个元素，然后递归求解for i in range(len(ss)):for j in self.Permutation(ss[:i]+ss[i+1:]):ret.append(ss[i]+j)#通过set进行去重，sorted进行重新排序return sorted(list(set(ret))) 注：递归算法，permutations(p[,r]);返回p中任意取r个元素做排列的元组的迭代器
28.数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
# -*- coding:utf-8 -*-
class Solution:def MoreThanHalfNum_Solution(self, numbers):# write code heredict = {}for i in numbers:if not dict.has_key(i):dict[i] = 1else:dict[i] = dict[i] + 1if dict[i] > len(numbers)/2:return ireturn 029.输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
# -*- coding:utf-8 -*-
class Solution:def GetLeastNumbers_Solution(self, tinput, k):# write code hereif tinput == [] or k > len(tinput):return []tinput.sort()return tinput[: k]32.输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323
# -*- coding:utf-8 -*-
class Solution:def PrintMinNumber(self, numbers):# write code hereif not numbers: return ""numbers = list(map(str, numbers))numbers.sort(cmp=lambda x, y: cmp(x + y, y + x))return "".join(numbers).lstrip('0') or'0'33.把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
# -*- coding:utf-8 -*-
class Solution:def GetUglyNumber_Solution(self, index):# write code hereres=[2**i*3**j*5**k for i in range(30) for j in range(20) for k in range(15)]res.sort()return res[index-1] if index else 0注：先从丑数的定义我们知道，一个丑数的因子只有2,3,5，那么丑数p = 2 ^ x * 3 ^ y * 5 ^ z，换句话说一个丑数一定由另一个丑数乘以2或者乘以3或者乘以5得到，那么我们从1开始乘以2,3,5，就得到2,3,5三个丑数，在从这三个丑数出发乘以2,3,5就得到
34.在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）
# -*- coding:utf-8 -*-
class Solution:def FirstNotRepeatingChar(self, s):# write code herereturn s.index(list(filter(lambda c:s.count(c)==1,s))[0]) if s else -1python简单方法：class Solution:def FirstNotRepeatingChar(self, s):# write code hereif len(s)<0:return -1for i in s:if s.count(i)==1:return s.index(i)breakreturn -1
书中所述创建哈希表，下标为ACII值，值为出现次数#建立哈希表,字符长度为8的数据类型,共有256种可能,于是创建一个长度为256的列表ls=[0]*256#遍历字符串,下标为ASCII值,值为次数for i in s:ls[ord(i)]+=1#遍历列表,找到出现次数为1的字符并输出位置for j in s:if ls[ord(j)]==1:return s.index(j)breakreturn -136.输入两个链表，找出它们的第一个公共结点。
依次将链表中的元素压入两个栈中，然后每次从两个栈中抛出一个元素，直到抛出的结点相同时返回
后面的元素都是公共的
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:def FindFirstCommonNode(self, pHead1, pHead2):# write code herelst1 = []lst2 = []result = []if not pHead1 or not pHead2:return Nonep1 = pHead1p2 = pHead2while p1:lst1.append(p1)p1 = p1.nextwhile p2:lst2.append(p2)p2 = p2.nextwhile lst1 and lst2:node1 = lst1.pop()node2 = lst2.pop()if node1 == node2:result.append(node1)if result:node = result.pop()return node37.统计一个数字在排序数组中出现的次数。
# -*- coding:utf-8 -*-
class Solution:def GetNumberOfK(self, data, k):# write code herereturn data.count(k)38.例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
class Solution:def FindGreatestSumOfSubArray(self, array):# write code hereif not array:return 0n = len(array)dp = [ i for i in array]for i in range(1,n):dp[i] = max(dp[i-1]+array[i],array[i])return max(dp)40.一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
def FindNumsAppearOnce(self, array):hashMap = {}for i in array:if str(i) in hashMap:hashMap[str(i)] += 1else:hashMap[str(i)] = 1res = []for k in hashMap.keys():if hashMap[k] == 1:res.append(int(k))return res注：Counter是一个简单的计数器，Counter 是一个有助于 hashable 对象计数的 dict 子类。它是一个无序的集合，其中 hashable 对象的元素存储为字典的键，它们的计数存储为字典的值，计数可以为任意整数，包括零和负数。
41.小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
# -*- coding:utf-8 -*-
class Solution:def FindContinuousSequence(self, tsum):# write code hereres = []small = 1big = 2mid = (1 + tsum) / 2curSum = small + bigwhile small < mid:if curSum == tsum:res.append(range(small, big + 1))small += 2big += 1curSum -= small * 2 - 3curSum += bigelif curSum < tsum:big += 1curSum += bigelse:curSum -= smallsmall += 1return res42.输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
# -*- coding:utf-8 -*-
class Solution:def FindNumbersWithSum(self, array, tsum):# write code herefor i in array:if tsum-i in array:if tsum-i==i:if array.count(i)>1:return [i,i]else:return [i,tsum-i]return []43.汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
# -*- coding:utf-8 -*-
class Solution:def LeftRotateString(self, s, n):# write code herereturn 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两种解法return " ".join(s.split()[::-1]) if s.strip() != "" else sreturn " ".join(s.split(" ")[::-1])47.求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
# -*- coding:utf-8 -*-
class Solution:def Sum_Solution(self, n):# write code herereturn (n+1)*n/248.写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
# -*- coding:utf-8 -*-
class Solution:def Add(self, num1, num2):# write code herereturn sum([num1,num2])49.将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
# -*- coding:utf-8 -*-
class Solution:def StrToInt(self, s):# write code heretry:return int(s)except:return 050.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
# -*- coding:utf-8 -*-
class Solution:# 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]# 函数返回True/Falsedef duplicate(self, numbers, duplication):# write code hereif not numbers:return Falsefor n in numbers:if numbers.count(n) > 1:duplication[0] = nreturn Truereturn False55.给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
# -*- coding:utf-8 -*-
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:def EntryNodeOfLoop(self, pHead):slow,fast=pHead,pHeadwhile fast and fast.next:slow=slow.nextfast=fast.next.nextif slow==fast:slow2=pHeadwhile slow!=slow2:slow=slow.nextslow2=slow2.nextreturn slow56.请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
# Python 简单解法，判断左右子节点的值是否相同即可，并通过递归左右节点遍历整个树# -*- 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 hereif not pRoot:return Truedef Traversal(left, right):if left is None and right is None:return Trueelif left and right and left.val == right.val:return Traversal(left.left, right.right) and Traversal(left.right, right.left)else:return Falsereturn Traversal(pRoot.left, pRoot.right)57.输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
# -*- coding:utf-8 -*-
class Solution:def FindNumbersWithSum(self, array, tsum):# write code hereif array is None or len(array)==0:return []i, j = 0, len(array)-1while i<=j:if array[i]+array[j] == tsum:return [array[i], array[j]]elif array[i]+array[j] > tsum:j -= 1elif array[i]+array[j] < tsum:i += 1return []使用两个指针，一个指向头部一个指向尾部
58.输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序
# -*- coding:utf-8 -*-
class Solution:def FindContinuousSequence(self, tsum):if tsum < 3:return []res = []small = 1big = 2mid = (1 + tsum) / 2curSum = small + bigwhile small < mid:if curSum == tsum:res.append(range(small, big + 1))small += 2big += 1curSum -= small * 2 - 3curSum += bigelif curSum < tsum:big += 1curSum += bigelse:curSum -= smallsmall += 1return res59.一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
# -*- coding:utf-8 -*-
from collections import Counter
class Solution:# 返回[a,b] 其中ab是出现一次的两个数字def FindNumsAppearOnce(self, array):# write code herehashMap = {}for i in array:if str(i) in hashMap:hashMap[str(i)] += 1else:hashMap[str(i)] = 1res = []for k in hashMap.keys():if hashMap[k] == 1:res.append(int(k))return res60.输入一棵二叉树，判断该二叉树是否是平衡二叉树。
class Solution:def IsBalanced_Solution(self, root):if not root:return Trueif abs(self.maxDepth(root.left) - self.maxDepth(root.right)) > 1:return Falsereturn self.IsBalanced_Solution(root.left) and self.IsBalanced_Solution(root.right)def maxDepth(self, root):if not root: return 0return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1如果二叉树的每个节点的左子树和右子树的深度不大于1，它就是平衡二叉树。
61.旋转数组的最小数字
# -*- coding:utf-8 -*-
class Solution:def minNumberInRotateArray(self, rotateArray):# write code herep1 = 0 p2 = len(rotateArray)-1 mid = p1 while rotateArray[p1]>=rotateArray[p2]: if p2 - p1 ==1: mid = p2 break mid =(p1+p2)>>1 if rotateArray[mid]>=rotateArray[p1]: p1 = mid elif rotateArray[mid] <= rotateArray[p2]: p2 =mid return rotateArray[mid] 62.输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
# -*- coding:utf-8 -*-
class Solution:def VerifySquenceOfBST(self, sequence):# write code hereif sequence==None or len(sequence)==0:return Falselength=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=Trueif i>0:left=self.VerifySquenceOfBST(sequence[0:i])# 判断 右子树是否为二叉树right=Trueif i<length-1:right=self.VerifySquenceOfBST(sequence[i:-1])return left and right注：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
63.输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
- 递归先序遍历树， 把结点加入路径。
- 若该结点是叶子结点则比较当前路径和是否等于期待和。
- 弹出结点，每一轮递归返回到父结点时，当前路径也应该回退一个结点
# -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution:# 返回二维列表，内部每个列表表示找到的路径def FindPath(self, root, expectNumber):# write code hereif not root:return []result = []def FindPathMain(root, path, currentSum):currentSum += root.valpath.append(root)isLeaf = root.left == None and root.right == Noneif currentSum == expectNumber and isLeaf:onePath = []for node in path:onePath.append(node.val)result.append(onePath)if currentSum < expectNumber:if root.left:FindPathMain(root.left, path, currentSum)if root.right:FindPathMain(root.right, path, currentSum)path.pop()FindPathMain(root, [], 0)return result64.输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
先中序遍历，将所有的节点保存到一个列表中。对这个list[:-1]进行遍历，每个节点的right设为下一个节点，下一个节点的left设为上一个节点。
# -*- 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 hereif not pRootOfTree:returnself.arr = []self.midTraversal(pRootOfTree)for i,v in enumerate(self.arr[:-1]):v.right = self.arr[i + 1]self.arr[i + 1].left = vreturn self.arr[0]def midTraversal(self, root):if not root: returnself.midTraversal(root.left)self.arr.append(root)self.midTraversal(root.right)65.输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
# -*- 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 hereif pRoot==None:return 0return max(self.TreeDepth(pRoot.left),self.TreeDepth(pRoot.right))+166请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是
# -*- coding:utf-8 -*- import re class Solution:def isNumeric(self, s):return re.match(r"^[\+\-]?[0-9]*(\.[0-9]*)?([eE][\+\-]?[0-9]+)?$",s)67.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表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 hereif pHead == None or pHead.next == None:return pHeadnew_head = ListNode(-1)new_head.next = pHeadpre = new_headp = pHeadnex = Nonewhile p != None and p.next != None:nex = p.nextif p.val == nex.val:while nex != None and nex.val == p.val:nex = nex.nextpre.next = nexp = nexelse:pre = pp = p.nextreturn new_head.next68.给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路，如果这道题是求中序遍历，肯定很简单。所以我们先写一个中序遍历的算法。关键是从根节点开始遍历，所以第一步还是找到某个节点的根节点，方法是一直使用next判断即可。
再将从根节点中序遍历的结果保存到一个数组中，直接找pNode所在索引的下一个即可。当然要考虑这个节点是不是最后一个，如果是最后一个，直接返回None
# 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 heredummy = pNodewhile dummy.next:dummy = dummy.nextself.result = []self.midTraversal(dummy)return self.result[self.result.index(pNode) + 1] if self.result.index(pNode) != len(self.result) - 1 else Nonedef midTraversal(self, root):if not root: returnself.midTraversal(root.left)self.result.append(root)self.midTraversal(root.right)69.从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
# -*- 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 hereif not pRoot:return []nodeStack = [pRoot]result = []while nodeStack:res = []nextStack = []for i in nodeStack:res.append(i.val)if i.left:nextStack.append(i.left)if i.right:nextStack.append(i.right)nodeStack = nextStackresult.append(res)return result70.给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
# class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution:# 返回对应节点TreeNodedef KthNode(self, pRoot, k):# write code hereself.res=[]self.dfs(pRoot)return self.res[k-1] if 0<k<=len(self.res) else Nonedef dfs(self,root):if not root:returnself.dfs(root.left)self.res.append(root)self.dfs(root.right)
剑指OFFER（持续更新中...)相关推荐
- 【每日一题】剑指 Offer 22. 链表中倒数第k个节点
剑指 Offer 22. 链表中倒数第k个节点
- 【LeetCode】剑指 Offer 51. 数组中的逆序对
[LeetCode]剑指 Offer 51. 数组中的逆序对 文章目录 [LeetCode]剑指 Offer 51. 数组中的逆序对 package offer;public class Soluti ...
- 【LeetCode】剑指 Offer 41. 数据流中的中位数
[LeetCode]剑指 Offer 41. 数据流中的中位数 文章目录 [LeetCode]剑指 Offer 41. 数据流中的中位数 package offer;import java.util. ...
- 【LeetCode】剑指 Offer 56. 数组中数字出现的次数
[LeetCode]剑指 Offer 56. 数组中数字出现的次数 文章目录 [LeetCode]剑指 Offer 56. 数组中数字出现的次数 package offer;import java.u ...
- 【LeetCode】剑指 Offer 39. 数组中出现次数超过一半的数字
[LeetCode]剑指 Offer 39. 数组中出现次数超过一半的数字 文章目录 [LeetCode]剑指 Offer 39. 数组中出现次数超过一半的数字 一.摩尔投票法 一.摩尔投票法 核心理 ...
- 【LeetCode】剑指 Offer 61. 扑克牌中的顺子
[LeetCode]剑指 Offer 61. 扑克牌中的顺子 文章目录 [LeetCode]剑指 Offer 61. 扑克牌中的顺子 一.集合Set + 遍历 二.排序 + 遍历 总结 解题思路 根据 ...
- 【LeetCode】剑指 Offer 62. 圆圈中最后剩下的数字
[LeetCode]剑指 Offer 62. 圆圈中最后剩下的数字 文章目录 [LeetCode]剑指 Offer 62. 圆圈中最后剩下的数字 一.动态规划 总结 一.动态规划 构建一个长度为 n ...
- 【LeetCode】剑指 Offer 22. 链表中倒数第k个节点
[LeetCode]剑指 Offer 22. 链表中倒数第k个节点 文章目录 [LeetCode]剑指 Offer 22. 链表中倒数第k个节点 一.遍历 二.双指针 总结 一.遍历 先遍历统计链表长 ...
- 【算法】剑指 Offer 12. 矩阵中的路径
文章目录 1.概述 2.我的算法 2.1 棋盘 2.1 开始节点 2.2 点没被访问 2.3 点是否在棋盘内 2.4 下一步 2.5 主方法 2.6 核心方法 2.7 测试类 3.leecode1 1 ...
- 力扣—— 19. 删除链表的倒数第 N 个结点（java）、剑指 Offer 22. 链表中倒数第k个节点（java）
19. 删除链表的倒数第 N 个结点(java) 一.题目描述 给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点. 进阶:你能尝试使用一趟扫描实现吗? 输入:head = [1,2,3 ...
最新文章
- SD-WAN — 技术架构
- 线段树 区间更新模板
- 2款在线FM音乐聚合播放PHP源码 带搜索
- 远程LInux和秘钥认证
- jmeter 跨线程执行变量
- 知名社交网络 Myspace 丢失 12 年用户数据，大型系统究竟如何做迁移？
- Java Scanner类nextLine和nextInt不能同用问题
- 毕设题目：Matlab优化调度
- 人人商城前端小程序如何配置使用教程
- 迅雷x导入未完成任务失败的解决办法。
- android win7 共享网络打印机,win7设置局域网共享打印机
- php中thead怎么居中,html thead标签怎么用
- 解决nginx emerg bind to 80 failed 98 Address alrea
- python try命令_python try语句(try/except/else/finally) Assertions
- Python经典案例：身体指数BMI
- HCIE-Security Day41：理论学习：信息收集与网络探测
- MYSQL数据库四种储存引擎
- MT6572的所有版本对语音解锁和语音控制功能的支持情况
- Linux新手的选择：Deepin（深度操作系统）
- uni-app 实现省市区三级联动