用JS刷剑指offer

1.二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

//DFS，递归
function TreeDepth(pRoot)
{if (pRoot==null){return 0;}let leftheight=TreeDepth(pRoot.left);let rightheight=TreeDepth(pRoot.right);return Math.max(leftheight,rightheight)+1;
}

//BFS
function TreeDepth(pRoot)
{let level=0;if (pRoot==null){return 0;}let queue=[pRoot];while(queue.length!=0){let len=queue.length;while(len--){//遍历每一层let cur=queue.shift();if(cur.left!=null){queue.push(cur.left);}if(cur.right!=null){queue.push(cur.right);} }level++;}return level;
}

2.数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

function duplicate(numbers, duplication)
{if(numbers==null){return false;}let count=new Array(1000).fill(0);for(let i=0;i<numbers.length;i++){if(count[numbers[i]]==1){duplication[0]=numbers[i];return true;}else{count[numbers[i]]=1;}}return false;
}

3.求1+2+3+…+n
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

function Sum_Solution(n)
{let sum=Math.pow(n,2)+n;return sum>>1;//右移相当于除以2
}

4.剪绳子
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1，m<=n），每段绳子的长度记为k[1],…,k[m]。请问k[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

/*** 题目分析：* 先举几个例子，可以看出规律来。* 4 ： 2*2* 5 ： 2*3* 6 ： 3*3* 7 ： 2*2*3 或者4*3* 8 ： 2*3*3* 9 ： 3*3*3* 10：2*2*3*3 或者4*3*3* 11：2*3*3*3* 12：3*3*3*3* 13：2*2*3*3*3 或者4*3*3*3** 下面是分析：* 首先判断k[0]到k[m]可能有哪些数字，实际上只可能是2或者3。* 当然也可能有4，但是4=2*2，我们就简单些不考虑了。* 5<2*3,6<3*3,比6更大的数字我们就更不用考虑了，肯定要继续分。* 其次看2和3的数量，2的数量肯定小于3个，为什么呢？因为2*2*2<3*3，那么题目就简单了。* 直接用n除以3，根据得到的余数判断是一个2还是两个2还是没有2就行了。* 由于题目规定m>1，所以2只能是1*1，3只能是2*1，这两个特殊情况直接返回就行了。
function cutRope(number)
{if(number===2) return 1;if(number===3) return 2;let a=Math.floor(number/3),b=number%3;switch(b){case 0:return Math.pow(3,a);case 1:return Math.pow(3,a-1)*4;case 2:return Math.pow(3,a)*2;   }
}

5.把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。

/* function TreeNode(x) {this.val = x;this.left = null;this.right = null;
} */
function Print(pRoot)
{if(pRoot==null){return [];}let queue=[pRoot];let que=[];while(queue.length){let len=queue.length;var temp=[];while(len--){           let cur=queue.shift();temp.push(cur.val);if(cur.left!=null){queue.push(cur.left);}if(cur.right!=null){queue.push(cur.right);}}que.push(temp);}return que;
}

6.二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。

/* function TreeNode(x) {this.val = x;this.left = null;this.right = null;
} */
function Mirror(root)
{if(root===null){return null;}let temp = root.left;root.left = root.right;root.right =temp;Mirror(root.left);Mirror(root.right);
}

7.变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

function jumpFloorII(number)
{if(number==1){return 1;}else{return jumpFloorII(number-1)*2;}
}

8.两个栈来实现一个队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

var stack1=[],stack2=[];
function push(node)
{stack1.push(node);
}
function pop()
{if(stack2.length==0){if(stack1.length==0){return null;            }else{while(stack1.length!=0){stack2.push(stack1.pop());}}return stack2.pop();}else{return stack2.pop();}
}

9.整数中1出现的次数
求出1_{13的整数中1出现的次数,并算出100}1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。

function NumberOf1Between1AndN_Solution(n)
{let num=0;for(let i=1;i<=n;i++){i.toString().split('').forEach( item=>{if(item=='1'){num++;}})}return num;
}

10.旋转数组的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

function minNumberInRotateArray(rotateArray)
{if(rotateArray.length==0){return 0;}for(let i=0;i<rotateArray.length-1;i++){if(rotateArray[i+1]<rotateArray[i]){return rotateArray[i+1];}}}

11.数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。

var arr=[];
function Insert(num)
{arr.push(num);for(let i=arr.length-2;arr[i]>num;i--){[arr[i],arr[i+1]]=[arr[i+1],arr[i]];}
}
function GetMedian(){if(arr.length%2===1){return arr[(arr.length-1)/2];}else{return (arr[arr.length/2]+arr[arr.length/2-1])/2;}
}

12.矩形覆盖
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

比如n=3时，2*3的矩形块有3种覆盖方法：

function rectCover(number)
{if(number==0||number==1||number==2){return number;}else{return rectCover(number-1)+rectCover(number-2);}
}

13.跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

function jumpFloor(number)
{if(number<=2){return number;}else{return jumpFloor(number-1)+jumpFloor(number-2);}
}

14.和为S的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

function FindContinuousSequence(sum)
{if(sum==0){return 0;}let arr=[];for(let i=1;i<=Math.ceil(sum/2);i++){let total=0;let count=0;for(let j=i;j<sum;j++){total+=j;count++;if(total==sum){let curr=[];for(let k=0;k<count;k++){curr.push(i+k);}arr.push(curr);break;}else if(total>sum){break;}}}return arr;
}

15.数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

保证base和exponent不同时为0

function Power(base, exponent)
{let cal=1;if(exponent==0){return 1;}else if(exponent>0){for(let i=0;i<exponent;i++){cal*=base;}}else{exponent=-exponent;for(let i=0;i<exponent;i++){cal*=base;}cal=1/cal;}return cal;
}

16.二进制中1的个数
输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。

function NumberOf1(n)
{let flag=1,count=0;while(flag){if(flag&n){count++;}flag=flag<<1;}return count;
}

17.和为S的两个数

function FindNumbersWithSum(array, sum)
{let left=0;let right=array.length-1;let arr=[];let min=[];while(left<right){let cursum=array[left]+array[right];if(cursum==sum){arr.push([array[left],array[right]]);left++;right--;}else if(cursum<sum){left++;}else{right--;}}min = arr.length && arr[0];for (let i = 1; i < arr.length; i++) {if (arr[i][0] * arr[i][1] < min[0] * min[1]) {min = arr[i];}}return min;
}

18.数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

function FindNumsAppearOnce(array)
{let n=array.length;let list=[];let acount=new Array(1000).fill(0);for(let i=0;i<n;i++){acount[array[i]]++;}for(let i=0;i<acount.length;i++){if(acount[i]==1){list.push(i);}}return list;
}

19.数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。

function GetNumberOfK(data, k)
{let count=0;let i=data.indexOf(k);while(data[i]==k){count++;i++;}return count;
}

20.连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

function FindGreatestSumOfSubArray(array)
{let mem=[array[0]];let max=array[0];for(let i=1;i<array.length;i++){mem[i]=Math.max(mem[i-1]+array[i],array[i]);}for(let i=0;i<mem.length;i++){max=Math.max(mem[i],max);}return max;
}

21.数组中有一个数字出现的次数超过数组长度的一半
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

function MoreThanHalfNum_Solution(numbers)
{let n=Math.floor(numbers.length/2);let list=new Set(numbers);let lists = Array.from(list);for(var i=0;i<lists.length;i++){let count=0;        for(var j=0;j<numbers.length;j++){if(numbers[j]==lists[i]){count++;}}if(count>n){return lists[i];break;}}return 0;}

22.字符流中第一个只出现一次的字符
题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。

//Init module if you need
let map={};
function Init()
{map={};
}
//Insert one char from stringstream
function Insert(ch)
{map[ch]=map[ch]?map[ch]+1:1;
}
//return the first appearence once char in current stringstream
function FirstAppearingOnce()
{for(let i in map){if(map[i]===1){return i;break;}}return '#';
}

23.表示数值的字符串
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。

//s字符串
function isNumeric(s)
{return !isNaN(s);
}

24.扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何，如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

function IsContinuous(numbers)
{if(numbers.length!=5){return false;}let count=0;let dis=0;numbers.sort((a,b)=>a-b);for(let i=0;i<numbers.length;i++){if(numbers[i]==0){count++;}}for(let i=4;i>count;i--){dis+=numbers[i]-numbers[i-1]-1;if(numbers.indexOf(numbers[i])!=i){return false;}}if(count<dis){return false;}else{return true;}}

25.左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

function LeftRotateString(str, n)
{if(!str||str.length==0){return '';}n=n%str.length;return str.slice(n)+str.slice(0,n);
}

26.链表中环的入口结点
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

/*function ListNode(x){this.val = x;this.next = null;
}*/
function EntryNodeOfLoop(pHead)
{if(!pHead){return null;}let arr=[];let temp=pHead;while(temp){if(arr.indexOf(temp)!=-1){return temp;}else{arr.push(temp);temp=temp.next;}}return null;
}

27.孩子们的游戏(圆圈中最后剩下的数)
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!^_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

如果没有小朋友，请返回-1

function LastRemaining_Solution(n, m)
{if(n<=0||m<1){return -1;}let children=[];for(let i=0;i<n;i++){children[i]=i;}let del=0;while(children.length>1){del=(del+m-1)%children.length;children.splice(del,1);}return children[0];
}

28.两个链表的第一个公共结点
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

/*function ListNode(x){this.val = x;this.next = null;
}*/
function FindFirstCommonNode(pHead1, pHead2)
{if(pHead1==null||pHead2==null){return null;}let node1=pHead1;let node2=pHead2;let arr=[];while(node1){arr.push(node1);node1=node1.next;}while(node2){if(arr.indexOf(node2)!=-1){return node2;}node2=node2.next;}return null;
}

29.合并两个排序的链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*function ListNode(x){this.val = x;this.next = null;
}*/
function Merge(pHead1, pHead2)
{if(pHead1 === null) return pHead2;else if(pHead2 === null) return pHead1;let node1=pHead1;let node2=pHead2;if(node1.val<=node2.val){var merge=node1;var root=merge;node1=node1.next;}else{var merge=node2;var root=merge;node2=node2.next;}while(node1!=null&&node2!=null){if(node1.val<=node2.val){merge.next=node1;merge=merge.next;node1=node1.next;}else{merge.next=node2;merge=merge.next;node2=node2.next;}}if(node1==null){while(node2!=null){merge.next=node2;merge=merge.next;node2=node2.next;}}else{while(node1!=null){merge.next=node1;merge=merge.next;node1=node1.next;}}return root;
}

30.反转链表
输入一个链表，反转链表后，输出新链表的表头。

/*function ListNode(x){this.val = x;this.next = null;
}*/
function ReverseList(pHead)
{let arr=[];let node1=pHead;let cur=pHead;let res=cur;while(node1!=null){arr.push(node1.val);node1=node1.next;}arr.reverse();for(let i=0;i<arr.length;i++){cur.val=arr[i];cur=cur.next;}return res;}

31.二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

/* function TreeNode(x) {this.val = x;this.left = null;this.right = null;
} */
function Convert(pRootOfTree)
{if(!pRootOfTree){return null;}let stack=[];let p=pRootOfTree;let isFirst=true;var pre,first,last;while(p!=null||stack.length>0){while(p){stack.push(p);p=p.left;}p=stack.pop();if(isFirst){first=p;pre=p;isFirst=false;          }else{p.left=pre;pre.right=p;pre=p;}p=p.right;}return first;
}

32.二叉树的下一个结点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

/*function TreeLinkNode(x){this.val = x;this.left = null;this.right = null;this.next = null;
}*/
//1、有右子树的，那么下个结点就是右子树最左边的点；（eg：D，B，E，A，C，G） ，那么父节点就是下一个节点 ；
// 2、没有右子树的，也可以分成两类，
//a)是父节点左孩子（eg：N，I，L）
//b)是父节点的右孩子（eg：H，J，K，M）找他的父节点的父节点的父节点...直到当前结点是其父节点的左孩子位置(数拐弯的位置)_。如果没有eg：M，那么他就是尾节点。
function GetNext(pNode)
{if(pNode==null){//空树return null;}let p=pNode;if(p.right){//有右子树p=p.right;while(p.left){p=p.left;}return p;}else{//没有右子树if(p.next&&p.next.left==pNode){//是父节点左孩子return p.next;}while(p.next){//是父节点右孩子p=p.next;if(p.next&&p.next.left==p){return p.next;}}}return null;//树最后一个节点
}

33.平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。

在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

/* function TreeNode(x) {this.val = x;this.left = null;this.right = null;
} */
function IsBalanced_Solution(pRoot)
{if(pRoot==null){return true;}let l1=treeDepth(pRoot.left);let l2=treeDepth(pRoot.right);let cal=Math.abs(l1-l2);if(cal<=1){return true;}return false;}
function treeDepth(pRoot){if(pRoot==null){return 0;}let leftDepth=treeDepth(pRoot.left);let rightDepth=treeDepth(pRoot.right);return Math.max(leftDepth,rightDepth)+1;
}

34.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/* function TreeNode(x) {this.val = x;this.left = null;this.right = null;
} */
function reConstructBinaryTree(pre, vin)
{let res={};if(pre.length==0){return null;}if(pre.length==1){res.val=pre[0];res.left=null;res.right=null;}else{let root=pre[0];let index=vin.indexOf(root);let vin1=vin.slice(0,index);let vin2=vin.slice(index+1,vin.length);pre.shift();let pre1=pre.slice(0,vin1.length);let pre2=pre.slice(vin1.length,pre.length);res.val=root;res.left=reConstructBinaryTree(pre1, vin1);res.right=reConstructBinaryTree(pre2, vin2);}return res;
}

35.第一个只出现一次的字符
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）

function FirstNotRepeatingChar(str)
{let map=new Map();for(let i=0;i<str.length;i++){if(!map[str[i]]){map[str[i]]=1;}else {map[str[i]]++;}}for(let key in map){if(map[key]==1){return str.indexOf(key);}}return -1;
}

36.二维数组中的查找

function Find(target, array) {for(let i=0;i<array.length;i++){if(array[i][0]>target || array[i][array[i].length-1]<target) continue;let low = 0, high = array[i].length - 1, mid;while (low <= high){mid = Math.floor((low+high)/2);if(array[i][mid] > target) high = mid-1;if(array[i][mid] < target) low = mid+1;if(array[i][mid] === target) return true;}}return false;
}
module.exports = {Find : Find
};

用JS刷剑指offer相关推荐

【Algorithm】用JS刷剑指offer
1 二维数组的查找题目描述在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断 ...
JS版剑指offer
JS版剑指offer JS刷题总结牛客网递归算法的时间复杂度:递归的总次数*每次递归的数量. 递归算法的空间复杂度:递归的深度*每次递归创建变量的个数. 二叉树(12道): 剑指Offer(4): ...
C#刷剑指Offer | 【常考题】最小的k个数
[C#刷题]| 作者 / Edison Zhou 这是EdisonTalk的第299篇学习分享我们来用之前学到的数据结构知识来刷<剑指Offer>的一些核心题目(精选了其中30+道题目) ...
C#刷剑指Offer | 二叉树中和为某一值的路径
[C#刷题]| 作者 / Edison Zhou 这是EdisonTalk的第292篇原创内容我们来用之前学到的数据结构知识来刷<剑指Offer>的一些核心题目(精选了其中30+道题目) ...
C#刷剑指Offer | 二叉搜索树的后序遍历序列
[C#刷题]| 作者 / Edison Zhou 这是EdisonTalk的第289篇原创内容我们来用之前学到的数据结构知识来刷<剑指Offer>的一些核心题目(精选了其中30+道题目) ...
C#刷剑指Offer | 从上到下打印二叉树
[C#刷题]| 作者 / Edison Zhou 这是EdisonTalk的第288篇原创内容我们来用之前学到的数据结构知识来刷<剑指Offer>的一些核心题目(精选了其中30+道题目) ...
C#刷剑指Offer | 在O(1)时间删除链表节点
[C#刷题]| 作者 / Edison Zhou 我们来用之前学到的数据结构知识来刷<剑指Offer>的一些核心题目(精选了其中30+道题目),希望对你有帮助!本文题目为:在O(1)时间删 ...
二刷剑指Offer：剑指Offer+LeetCode（全53题）
文章目录剑指Offer刷题 67. 剪绳子(贪心算法) 66. 机器人的运动范围(dfs) 65. 矩阵中的路径(回溯算法) 64. 滑动窗口的最大值(双端队列) 63. 数据流中的中位数 62. ...
《剑指offer》刷题总结
从三月初开始刷剑指offer上面的题,到现在花了近二十天的时间终于刷完了.应该说,掌握上面的技巧应付一些公司面试题和小公司的笔试题是完全没有问题的.之前参加一个公司笔试,算法题就有一题是剑指offer ...

用JS刷剑指offer

用JS刷剑指offer相关推荐

最新文章

热门文章