一、剑指 Offer 03. 数组中重复的数字
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
leetcode-cn.com/problems/sh…
//对象解法
var findRepeatNumber = function(nums) {
var obj={}
for(let i=0;i<nums.length;i++){
if(obj[nums[i]]){
return nums[i]
}else{
obj[nums[i]]=true
}
}
};
//排序解法
var findRepeatNumber = function(nums) {
var numsSort=nums.sort()
console.log(numsSort)
for(let i=0;i<nums.length;i++){
if(numsSort[i]==numsSort[i+1]){
return numsSort[i]
}
}
};
二、剑指 Offer 04. 二维数组中的查找
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
//从右上角开始查找
var findNumberIn2DArray = function(matrix, target) {
var row=matrix.length
if(row==0){
return false
}
var colom=matrix[0].length
var i=0,j=colom-1
while(i<row&&j>=0){
if(matrix[i][j]==target){
return true
}else if(matrix[i][j]>target){
j--
}else {
i++
}
}
return false
};
三、剑指 Offer 05. 替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
//正则表达式
var replaceSpace = function(s) {
console.log(s.replace(/\s/g,"%20"))//We%20are%20happy%20%20
console.log(s)
return s.replace(/\s/g,"%20");//We are happy
};
四、剑指 Offer 06. 从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
//并不改变原来的链表结构
//使用unshift
var reversePrint = function(head) {
if (head === null) return []
let array = [];
while(head != null){
array.unshift(head.val);
head = head.next;
}
return array;
};
//使用reverse
var reversePrint = function (head) {
if (head === null) return []
const res = []
while (head) {
res.push(head.val)
head = head.next
}
return res.reverse()
}
五、剑指 Offer 07. 重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
var buildTree = function(preorder, inorder) {
if (!preorder.length || !inorder.length) {
return null;
}
const rootVal = preorder[0];
const node = new TreeNode(rootVal);
let i = 0; // i有两个含义，一个是根节点在中序遍历结果中的下标，另一个是当前左子树的节点个数
for (; i < inorder.length; i++) {
if (inorder[i] === rootVal) {
break;//i的截止
}
}
node.left = buildTree(preorder.slice(1, i + 1), inorder.slice(0, i));//返回一个新的数组，包含从 start 到 end （不包括该元素）的 arrayObject 中的元素。
node.right = buildTree(preorder.slice(i + 1), inorder.slice(i + 1));
return node;
};
六、剑指 Offer 09. 用两个栈实现队列
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
var CQueue = function() {
this.stack1 = []
this.stack2 = []
};
CQueue.prototype.appendTail = function(value) {
this.stack1.push(value)
};
CQueue.prototype.deleteHead = function() {
// 一. 2 不为空,直接取
if (this.stack2.length) return this.stack2.pop()
// 二. 2 为空 循环1, 往2中继续添加元素
while(this.stack1.length){
this.stack2.push(this.stack1.pop())
}
return this.stack2.pop() || -1
}
//return a && b 如果a是true的话，返回b， 如果a是false的话，返回a
//return a || b 如果a是true的话，返回a，如果a是false的话，返回b 。
七、剑指 Offer 10- I. 斐波那契数列
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1
//注意:
//1、要在里面取模，不然在最后才弄的话，在高数字时就会出错。
//2、取模的概念：就是取余数。1除以2，商等于0，余数为1。2除以8，商等于0，余数为2。
//第一种
var fib = function(n) {
if(n === 0) return 0
if(n === 1) return 1
let res1 = 0
let res2 = 1
for(let i = 1;i<n;i++){
let t = res1
res1 = res2
res2 = (t + res2) % 1000000007
}
return res2
};
//第二种
var fib = function(n) {
if(n==0){
return 0
}
if(n==1){
return 1
}
var x=0
var y=1
while(n!=0){
y=x+y
x=(y-x)%1000000007
n-=1
}
return x
};
八、剑指 Offer 10- II. 青蛙跳台阶问题
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
//斐波那契数列的应用：当只有0或1级台阶时，只有一种跳法；当有2级台阶时，只有2中跳法；
//当有n>2种时，第一种情况取决于后面的n-1种情况，第二种情况取决于后面的n-2种情况
var numWays = function(n) {
if(n === 0) return 1
if(n === 1) return 1
if(n === 2) return 2
let res1 = 1
let res2 = 2
for(let i = 2;i<n;i++){
let t = res1
res1 = res2
res2 = (t + res2) % 1000000007
}
return res2
};
九、剑指 Offer 11. 旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
//二分查找，正确解
var minArray = function(numbers) {
var nums=numbers
var left = 0;
var right = nums.length - 1;
while (left < right) {
var mid = Math.floor(left + (right - left) / 2)
if (nums[mid] > nums[right]) {
left = mid + 1;
} else if (nums[mid] < nums[right]) {
right = mid;
} else {
right--;//在数组中有重复数字的解决方法
}
}
return nums[left];
};
//遍历：时间O(n)
var minArray = function(numbers) {
for(var i =0;i<numbers.length;i++){
if(numbers[i]<numbers[0])
return numbers[i];
}
return numbers[0];
};
（待）十、剑指 Offer 12. 矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。
[["a","b","c","e"],
["s","f","c","s"],
["a","d","e","e"]]
但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。
（待）十一、剑指 Offer 13. 机器人的运动范围
地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？
（待）十二、剑指 Offer 14- I. 剪绳子
给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]k[1]...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
（待）十三、剑指 Offer 14- II. 剪绳子 II
给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m - 1] 。请问 k[0]k[1]...*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
十四、剑指 Offer 15. 二进制中1的个数
请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
/*按位"与"赋值
x &= y 等于 x = x & y
0101 (result)
1100 (expression)
----
0100
只要两个表达式在某一位上都是 1，则结果的该位也是 1。否则，结果的该位是 0。
*/
//1、位"与"来解答
var hammingWeight = function(n) {
var count=0
while(n!==0){
n=n&(n-1)
count+=1
}
return count
};
（待）十五、剑指 Offer 16. 数值的整数次方
实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。
//香辣鸡排蛋包饭：https://www.bilibili.com/video/BV1z5411L756
（待）十六、剑指 Offer 17. 打印从1到最大的n位数
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
十七、剑指 Offer 18. 删除链表的节点
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
返回删除后的链表的头节点。
注意：此题对比原题有改动
//设一个dummy（假）节点，来顾虑一下头结点
var deleteNode = function(head, val) {
var dummy=new ListNode(0)
dummy.next=head
var prev=dummy
while(prev){
if(prev.next.val==val){
prev.next=prev.next.next
break
}else{
prev=prev.next
}
}
return dummy.next
};
（待）十八、剑指 Offer 19. 正则表达式匹配
请实现一个函数用来匹配包含'. '和''的正则表达式。模式中的字符'.'表示任意一个字符，而''表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。
（待）十九、剑指 Offer 20. 表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、"5e2"、"-123"、"3.1416"、"-1E-16"、"0123"都表示数值，但"12e"、"1a3.14"、"1.2.3"、"+-5"及"12e+5.4"都不是。
二十、剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
/*判断一个数是奇数还是偶数的方法：
1、取模操作
num%2==0 偶数（取余数）
num%2==1 奇数
2、使用位操作：二进制的末位为 0表示偶数，末位为 1表是奇数
(a & 1)==0 偶数
(a & 1)==1 奇数
*/
var exchange = function(nums) {
if(nums.length==0){
return []
}
var left=0
var right=nums.length-1
while(left<right){
console.log(nums[left]& 1 == 1)
console.log(nums[left]%2==1)
// while(left<right&&nums[left]%2==1){//如果是奇数就继续加
while(left<right&&(nums[left]&1)==1){//如果是奇数就继续加
left++
}
//while(right>left&&nums[right]%2==0){//如果是偶数就继续减
while(right>left&&(nums[right]&1)==0){//如果是偶数就继续减
right--
}
var temp=nums[left]
nums[left]=nums[right]
nums[right]=temp
left++
right--
}
return nums
};
二十一、剑指 Offer 22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
var getKthFromEnd = function(head, k) {
var slow=fast=head
for(let i=0;i<k;i++){//快指针先走k步
fast=fast.next
}
while(fast){
slow=slow.next
fast=fast.next
}
return slow
};
二十二、剑指 Offer 24. 反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
var reverseList = function(head) {
let pre=null
let curr=head
let next=null
while(curr){
//第一种:
next=curr.next
curr.next=pre
pre=curr
curr=next
//第二种：
//[curr.next,pre,curr]=[pre,curr,curr.next]
}
return pre
};
二十三、剑指 Offer 25. 合并两个排序的链表
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
var mergeTwoLists = function(l1, l2) {
var dummy=new ListNode(0)
var curr=dummy
while(l1&&l2){
if(l1.val<=l2.val){
curr.next=l1
l1=l1.next
}else{
curr.next=l2
l2=l2.next
}
curr=curr.next
}
curr.next=l1?l1:l2//如果l1存在，则等于l1,否则等于l2
return dummy.next
};
（要复习）二十四、剑指 Offer 26. 树的子结构
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
var isSubStructure = function(A, B) {
// 约定空树不是任意一个树的子结构
if(!A || !B) {
return false;
}
return isSameTree(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B)
};
var isSameTree = function(A, B) {
// B子树是空子树 ok
if(!B) {
return true;
}
// A子树是空子树 且 B 非空，不 ok
if(!A) {
return false;
}
// 当前节点的值不相等，不 ok
if(A.val !== B.val) {
return false;
}
// 递归考察左子树、右子树
return isSameTree(A.left, B.left) && isSameTree(A.right, B.right);
};
二十五、剑指 Offer 27. 二叉树的镜像
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
var mirrorTree = function(root) {
if(root==null) return root
var temp=root.left
root.left=root.right
root.right=temp
mirrorTree(root.left)
mirrorTree(root.right)
return root
};
二十六、剑指 Offer 28. 对称的二叉树
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
var isSymmetric = function(root) {
function judge(left,right){
if(left==null&&right==null) return true
if(left==null||right==null) return false
if(left.val!==right.val) {
return false
}//这里如果两个值如果相等，不可以return true，如果return了，下面的节点比较就不会继续下去了
return judge(left.left,right.right)&&judge(left.right,right.left)
}
if(root==null) return true
var res=judge(root.left,root.right)
return res
};
（待）二十七、剑指 Offer 29. 顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
二十八、剑指 Offer 30. 包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。
//注意：数组的原生方法中没有top()方法，所以得this.stackMin[lengthMin-1]取得顶部元素
var MinStack = function() {
this.stack=[]
this.stackMin=[]
};
MinStack.prototype.push = function(x) {
this.stack.push(x)
var lengthMin=this.stackMin.length
if(this.stackMin.length==0){
this.stackMin.push(x)
}else{
if(this.stackMin[lengthMin-1]>=x){
this.stackMin.push(x)
}else{
var x=this.stackMin[lengthMin-1]
this.stackMin.push(x)
}
}
};
MinStack.prototype.pop = function() {
this.stackMin.pop()
return this.stack.pop()
};
MinStack.prototype.top = function() {
return this.stack[this.stack.length-1]
};
MinStack.prototype.min = function() {
var lengthMin=this.stackMin.length
return this.stackMin[lengthMin-1]
};
二十九、剑指 Offer 31. 栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。
var validateStackSequences = function(pushed, popped) {
var popIndex=0
var stack=[]
for(var i=0;i<pushed.length;i++){
stack.push(pushed[i])
while(stack.length!==0&&stack[stack.length-1]==popped[popIndex]){//注意是stack[stack.length-1],而不是stack[i]
stack.pop()
popIndex++
}
}
// if(stack.length==0){
// return true
// }else{
// return false
// }
//简化写法
return !stack.length
};
三十、剑指 Offer 32 - I. 从上到下打印二叉树
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
//shift() 方法从数组中删除第一个元素，并返回该元素的值。
var levelOrder = function(root) {
if(!root) return []
var res=[]
var queue=[root]
while(queue.length!=0){
var first=queue.shift()
res.push(first.val)
first.left&&queue.push(first.left)
first.right&&queue.push(first.right)
}
return res
};
三十一、剑指 Offer 32 - II. 从上到下打印二叉树 II
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
var levelOrder = function(root) {
if(!root) return []
var res=[]
var queue=[root]
while(queue.length){
var temp=[]//重要
var levelLength=queue.length
console.log(levelLength)
for(var i=0;i<levelLength;i++){//错在这里卡了好久，错把i<levelLength;写成i<levelLength-1;因为0<0(1-1),所以for循环没有执行，所以queue.length一直等于1，所以一直循环到崩溃
var first=queue.shift()
temp.push(first.val)
first.left&&queue.push(first.left)
if(first.right) queue.push(first.right)
}
// console.log(temp)
res.push(temp)
}
return res
};
三十二、剑指 Offer 32 - III. 从上到下打印二叉树 III
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
var levelOrder = function(root) {
if(!root) return []
var res=[]
var queue=[root]
var level=1//重要
while(queue.length){
var temp=[]//重要
var levelLength=queue.length
console.log(levelLength)
for(var i=0;i<levelLength;i++){
var first=queue.shift()
if((level&1)==1){//奇数
temp.push(first.val)
}else{
temp.unshift(first.val)
}
first.left&&queue.push(first.left)
if(first.right) queue.push(first.right)
}
// console.log(temp)
res.push(temp)
level++ //重要
}
return res
};
（待）三十三、剑指 Offer 33. 二叉搜索树的后序遍历序列
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
（待）三十四、剑指 Offer 34. 二叉树中和为某一值的路径
输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
（待）三十五、剑指 Offer 35. 复杂链表的复制
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
（待）三十六、剑指 Offer 36. 二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
（待）三十七、剑指 Offer 37. 序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树。
（待）三十八、剑指 Offer 38. 字符串的排列
输入一个字符串，打印出该字符串中字符的所有排列。 你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
（待）三十九、剑指 Offer 39. 数组中出现次数超过一半的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
（待）四十、剑指 Offer 40. 最小的k个数
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
（待）四十一、剑指 Offer 41. 数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
（待）四十二、剑指 Offer 42. 连续子数组的最大和
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为O(n)
（待）四十三、剑指 Offer 43. 1～n 整数中 1 出现的次数
输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。
例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。
（待）四十四、剑指 Offer 44. 数字序列中某一位的数字
数字以0123456789101112131415…的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。
请写一个函数，求任意第n位对应的数字。
（待）四十五、剑指 Offer 45. 把数组排成最小的数
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
（待）四十六、剑指 Offer 46. 把数字翻译成字符串
给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。
（待）四十七、剑指 Offer 47. 礼物的最大价值
在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？
（待）四十八、剑指 Offer 48. 最长不含重复字符的子字符串
请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。
（待）四十九、剑指 Offer 49. 丑数
我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。
（待）五十、剑指 Offer 50. 第一个只出现一次的字符
在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。
（待）五十一、剑指 Offer 51. 数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
（待）五十二、剑指 Offer 52. 两个链表的第一个公共节点
输入两个链表，找出它们的第一个公共节点。
（待）五十三、剑指 Offer 53 - I. 在排序数组中查找数字 I
统计一个数字在排序数组中出现的次数。
（待）五十四、剑指 Offer 53 - II. 0～n-1中缺失的数字
一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。
（待）五十五、剑指 Offer 54. 二叉搜索树的第k大节点
给定一棵二叉搜索树，请找出其中第k大的节点。
（待）五十六、剑指 Offer 55 - I. 二叉树的深度
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。
（待）五十七、剑指 Offer 55 - II. 平衡二叉树
输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
（待）五十八、剑指 Offer 56 - I. 数组中数字出现的次数
一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
（待）五十九、剑指 Offer 56 - II. 数组中数字出现的次数 II
在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。
（待）六十、剑指 Offer 57. 和为s的两个数字
输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。
（待）六十一、剑指 Offer 57 - II. 和为s的连续正数序列
输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。
序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。
（待）六十二、剑指 Offer 58 - I. 翻转单词顺序
输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。
（待）六十三、剑指 Offer 58 - II. 左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
（待）六十四、剑指 Offer 59 - I. 滑动窗口的最大值
给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值
（待）六十五、剑指 Offer 59 - II. 队列的最大值
请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。
若队列为空，pop_front 和 max_value 需要返回 -1
（待）六十六、剑指 Offer 60. n个骰子的点数
把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。
你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。
（待）六十七、剑指 Offer 61. 扑克牌中的顺子
从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。
（待）六十八、剑指 Offer 62. 圆圈中最后剩下的数字
0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。
例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。
（待）六十九、剑指 Offer 63. 股票的最大利润
假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？
（待）七十、剑指 Offer 64. 求1+2+…+n
求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
（待）七十一、剑指 Offer 65. 不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。
（待）七十二、剑指 Offer 66. 构建乘积数组
给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。
（待）七十三、剑指 Offer 67. 把字符串转换成整数
写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。
（待）七十四、剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
（待）七十五、剑指 Offer 68 - II. 二叉树的最近公共祖先
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。
（待）Eending（即将开启新篇章）、面试题 01.01. 判定字符是否唯一
实现一个算法，确定一个字符串 s 的所有字符是否全都不同。 leetcode-cn.com/problems/is…
