1.二维数组中的查找
在一个二维数组中，每一行都根据从左到右递增的递次排序，每一列都根据从上到下递增的递次排序。请完成一个函数，输入如许的一个二维数组和一个整数，推断数组中是不是含有该整数。
function Find(target, array)
{
var row = array.length; // 行数
var col = array[0].length; // 列数
// 从左下角最先比较
var r = row - 1;
var c = 0;
while(r >= 0 && c <= col - 1) { // 注重这里有等于号
if (target > array[r][c]) {
c++;
}
else if (target < array[r][c]) {
r--;
}
else {
return true;
}
}
return false;
}
module.exports = {
Find : Find
};
2.替代空格
请完成一个函数，将一个字符串中的空格替代成“%20”。比方，当字符串为We Are Happy.则经由替代以后的字符串为We%20Are%20Happy。
function replaceSpace(str)
{
// write code here
return str.replace(/\s/g,'%20');
}
module.exports = {
replaceSpace : replaceSpace
};
3.从头至尾打印链表
/*function ListNode(x){
this.val = x;
this.next = null;
}*/
function printListFromTailToHead(head)
{
var res=[];
while(head){
res.unshift(head.val);
head=head.next;
}
return res;
}
module.exports = {
printListFromTailToHead : printListFromTailToHead
};
4.重修二叉树
输入某二叉树的前序遍历和中序遍历的效果，请重修出该二叉树。假定输入的前序遍历和中序遍历的效果中都不含反复的数字。比方输入前序遍历序列{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)
{
if (!pre || pre.length === 0) {
return;
}
var treeNode = {
val: pre[0]
}
for(var i = 0; i < pre.length; i++) {
if (vin[i] === pre[0]) {
treeNode.left = reConstructBinaryTree(pre.slice(1, i+1), vin.slice(0, i));
treeNode.right = reConstructBinaryTree(pre.slice(i+1),vin.slice(i+1));
}
}
return treeNode;
}
module.exports = {
reConstructBinaryTree : reConstructBinaryTree
};
5.用两个栈完成行列
用两个栈来完成一个行列，完成行列的Push和Pop操纵。 行列中的元素为int范例
function Stack(){
var arr = [];
this.push = function (node){
arr.push(node);
return arr;
};
this.pop = function(){
return arr.pop();
};
this.isEmpty = function(){
return arr.length === 0;
};
}
var stack1 = new Stack();
var stack2 = new Stack();
function push(node)
{
// write code here
stack1.push(node);
}
function pop()
{
// write code here
if(stack1.isEmpty() && stack2.isEmpty()){
throw new Error("empty queue");
}
if(stack2.isEmpty()){
while(!stack1.isEmpty()){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
module.exports = {
push : push,
pop : pop
};
6.扭转数组的最小数字
function minNumberInarr(arr) {
// write code here
var left = 0;
var right = arr.length-1;
var mid = left;
if (arr.length == 0) return;
while(arr[left] >= arr[right]){
if(right-left == 1){
mid = right;
break;
}
mid = Math.floor((left+right)/2)
if(arr[mid] >= arr[left]){
left = mid;
}
else if(arr[mid] < arr[left]){
right = mid;
}
else if(arr[mid] == arr[right] && arr[mid] == arr[left]){
return inOrder(arr);
}
}
return arr[mid];
}
function inOrder(arr){
var min = arr[0];
for(var i = 0; i
if(min > arr[i]){
min = arr[i];
}
}
return min;
}
7.斐波那契数列
输入一个整数n，请你输出斐波那契数列的第n项。
// 递归版本：
function f(n) {
if (n == 0 || n == 1) {
return n;
}
else {
return f(n-1) + f(n-2);
}
}
// 动态计划版本：
function f(n)
{
// write code here
if (n == 0 || n == 1) {
return n;
}
var f1 = 0;
var f2 = 1;
var temp;
for (var i = 2; i <= n; i++) {
temp = f1 + f2;
f1 = f2;
f2 = temp;
}
return f2;
}
8.跳台阶
一只田鸡一次能够跳上1级台阶，也能够跳上2级。求该田鸡跳上一个n级的台阶总共有若干种跳法。
function jumpFloor(n) {
//0,1,2,3,5,8....
if (n < 0) {
return;
}
if (n >=0 && n <= 2) {
return n;
}
var f1 = 1;
var f2 = 2;
var temp = 0;
for (var i = 0; i < n - 2; i++) {
temp = f1;
f1 = f2;
f2 = temp + f1;
}
return f2;
}
9.变态跳台阶
一只田鸡一次能够跳上1级台阶，也能够跳上2级……它也能够跳上n级。求该田鸡跳上一个n级的台阶总共有若干种跳法。
// 0 1 2 4 8 16 32 64...
function jumpFloorII(number)
{
if (number < 0) return;
if (number >= 0 && number <= 2) return number;
return 2 * jumpFloorII(number - 1)
}
10.矩形掩盖(不能AC)
我们能够用21的小矩形横着或许竖着去掩盖更大的矩形。叨教用n个21的小矩形无堆叠地掩盖一个2*n的大矩形，总共有若干种方法？
// 0,1,2,3,5,8,13,21...
function rectCover(number)
{
// write code here
if (number < 1) {
return 0;
}
else if (number == 1 || number == 2) {
return number;
}
else {
return rectCover(number - 1) + rectCover(number - 2);
}
}
转播
