剑指offer js编程题(更新中...)

二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

function Find(target, array)
{
    for ( i=0; i<array.length; i++ ) {
        var b = array[i]
        for(j=0; j<b.length; j++) {
            if (target==b[j]) {
                return true
            }
        }
    }
}

替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy

function replaceSpace(str)
{
    var str1 = str.replace(/ /g,'%20')
    return str1
}

从尾到头打印链表

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

function printListFromTailToHead(head)
{
    var arr = [];
    let p = head;
    while (p) {
        arr.push(p.val);
        p = p.next;
    }
    return arr.reverse()
}

旋转数组中的最小数

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

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

斐波那切数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n≤39

function Fibonacci(n)
{
    var a = [0,1];
    for(var i=2;i<=39;i++){
         var num = a[i-1]+a[i-2]
        a.push(num)
    }
    return a[n]
}

跳台阶

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

思路: 当青蛙跳到第n阶时,它的上一步一定是n-1或n-2阶,所以说它跳到第n阶的跳法是跳到第n-1阶和第n-2阶的方法之和,即f(n)=f(n-1)+f(n-2),类似于斐波那契数列

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

变态跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路: 该题和上题一样,逆向思考,当青蛙在第n阶时,它的上一阶可以是0,1,2…n-1阶,即f(n)=f(0)+f(1)+f(2)+…+f(n-1),当它在第0阶时只有一种跳法

function jumpFloorII(number)
{
    if (number == 0){
        return 1
    }else {
        var a = 0
        for(var i = 0;i<number;i++){
            a+=jumpFloorII(i)
        }
        return a
    }
}

矩形覆盖

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
依旧用到斐波那契数列

function rectCover(number)
{
    if(number<3){
        return number
    }
    return rectCover(number-1)+rectCover(number-2)
}

二进制中1的个数

输入一个整数，输出该数32位二进制表示中1的个数。其中负数用补码表示。
n&(n-1)位运算的妙用.

function NumberOf1(n)
{
    var total = 0
    while(n!==0){
        total++
        n = n&(n-1)
    }
    return total
}

数值的整数次方

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0

n次方计算方法：pow 方法
返回底表达式的指定次幂。
Math.pow(base, exponent)
参数
base
必选项。表达式底的值。

exponent
必选项。表达式的指数值。

function Power(base, exponent)
{
    return Math.pow(base, exponent)
}

调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

合并数组：concat

function reOrderArray(array)
{
    var odd = []
    var even = []
    for(var i = 0;i<array.length;i++){
        if(array[i]%2==1){
            odd.push(array[i])
        }else{
            even.push(array[i])
        }
    }
    return odd.concat(even)
}

字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

function Permutation(str)
{
    var arr = []
    if(str.length>1){
        for(var i = 0;i<str.length;i++){
        // 获取每个字母开头
        var first = str[i]
        // 获取除开头字母以外的所有字母
        var remain = str.slice(0,i)+str.slice(i+1,str.length)
        // 以剩余字母为参数自调用函数
        var remainstr = Permutation(remain)
        for(var j = 0;j<remainstr.length;j++){
        // 拼接函数
            var tem = first+remainstr[j]
            arr.push(tem)
        }
        }
    }else if(str.length==1){
        arr.push(str)
    }
    // 使用ES6进行数组去重
    return [...new Set(arr)]
}

数组中出现次数超过一半的数字

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

思路： 先将数组按顺序排列，如果有次数超过一半的数，那么它一定是最中间的那个数，因为它的个数要超过一半，所以即便是最小或最大的那个数，数组最中间的数也一定是它。所以我们只需要将数组最中间的数取出来，再统计它的个数，如果超过一半，返回该数，如果不超过一半，返回0

function MoreThanHalfNum_Solution(numbers)
{
    var n = numbers
    var l = n.length
    for(var i = 0;i<n.length;i++){
        for(var j = i+1;j<n.length;j++){
            if(n[i]>n[j]){
                var tem = n[i]
                n[i]=n[j]
                n[j]=tem
            }
        }
    }
    var a = Math.floor(l/2)
    var b = n[a]
    var total = 0
    for(var item = 0;item<n.length;item++){
        if(n[item] ==b){
            total+=1
        }
    }
    if(total>(l/2)){
        return b
    }else{
        return 0
    }
}

最小的k个数

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
思路： 先对数组进行排序，再使用slice方法截取所需的最小数组

function GetLeastNumbers_Solution(input, k)
{
        for(var i = 0;i<input.length-1;i++){
                for(var j = i+1;j<input.length;j++){
                    if(input[i]>input[j]){
                        var tem = input[i]
                        input[i]=input[j]
                        input[j]=tem
                    }
                }
            }
    if(k>input.length){
        return []
    }else{
        return input.slice(0,k)
    }
}

丑数

把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

思路：

借助 2 3 5 倍数原理来算
倍数* 2 3 5 就是满足条件的数字，
关键在于如何从小到达找出所有的这样满足条件的数字
那就是对于不同的2 3 5 用不同的指针去乘，每一乘完就找出三个数里面最小的，然后相应的指针++
直到找出最后的数字

function GetUglyNumber_Solution(index)
{
    if(index<7){
        return index
    }
    // 定义arr来储存丑数,默认第一个丑数是1，因此初始化arr=[1]
    var arr = [1]
    var p2 = 0
    var p3 = 0
    var p5 = 0
    for(var i = 0;i<index;i++){
   		 //1*   [2,3,5]得到[2,3,5]  这时将里面最小的数加到arr中，这时arr=[1,2]
        var tem = Math.min(arr[p2]*2,arr[p3]*3,arr[p5]*5)
        arr.push(tem)
        if(tem===arr[p2]*2){
            p2++
        }
        if(tem===arr[p3]*3){
            p3++
        }
        if(tem===arr[p5]*5){
            p5++
        }
    }
    return arr[index-1]
}

第一次只出现一次的字符位置

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）
思路：
先使用for循环获取到只出现一次的字符，然后在使用search方法得到它在字符串中的位置

function FirstNotRepeatingChar(str)
{
    var str1 = []
    for(var k=0;k<str.length;k++){
        str1.push(str[k])
    }
    str1 = [...new Set(str1)]
    var unique = []
    for(var i =0;i<str1.length;i++){
        var total = 0
        for(var j=0;j<str.length;j++){
            if(str1[i]==str[j]){
                total++
            }
        }
        if(total==1){
            unique.push(str1[i])
        }    
    }
    if(unique.length==0){
        return -1
    }else{
        return (str.search(unique[0]));
    }
}

求1+2+3+…+n

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

思路： 使用 a&&b 来进行判断，如果a成立，则执行b，如果a不成立，则不执行b

function Sum_Solution(n)
{
    var sum = 0
    add(n)
    return sum
    
    function add(a){
        sum+=a
        a>0&&add(--n)
    }
}