www.4688.com自得非是极度好的,可是我甘愿努力化极端好之挺

111. 爬楼梯

假定你正在爬楼梯,需要n步你才能够达顶部。但老是你只能爬一步还是简单步,你可知起多少种不同的方法爬至楼顶部?
题目链接

     现在在老伴,想方你,觉得十分暖和,
但愿下次降雪的时光咱们照例在联合,我还能够伴随在公,就这么年复一年的陪同在你直接到死老很老后……

样例

在词典

{
  "dog",
  "google",
  "facebook",
  "internationalization",
  "blabla"
}

被, 最丰富的单词集合为 [“internationalization”]

     
 路上琼哥起在车,我不由自主多看了外几目,感觉他吓兴奋,估计为跟我平,太久没有见了下雪了,所以开心到意外起,因为学太老了,所以车速非常缓慢,可是我还当好不久,好怀念车能再挪的冉冉一点,这样即便可以基本上以共一会,毕竟还有四天琼哥就使动了,然后就是是经久不衰的异地恋。

100.刨除排序数组中之重数字

受得一个排序数组,在原数组中去除重复出现的数字,使得每个元素就出现同样坏,并且返回新的数组的长短。

决不动额外的数组空间,必须于原地没有额外空间的规则下形成。
问题链接

     
 我知道自家一定不是极致好的太乖的太听话的,但是我情愿开深一直陪在公走不行长远很遥远的人数,无论发生什么,愿意联名顶。虽然本人产生下蛮横不讲道理,但是当别的事情上自都乐于举行你最精锐的支持,我耶会见努力改变少臭脾气。虽然现在的我平从业不管成,但是自深信努力坚持就会来获取,我吗甘愿努力,像你就那么。

样例

深受出链表 3->2->1->5->null和n = 2,返回倒数第二只节点的价1.

let nthToLast=(arr,p)=>{
    if(p>arr.length) return 'error position'
    return arr[arr.length-p]
}
let arr=[5,4,3,2,1]
console.log(nthToLast(arr,5)) //5

思路:js中无链表的概念,数组很好收获

   
 一直嚷嚷着减肥要薄到96斤,然而一直无兑现,等而活动了,下次会面一定得给您相自家得以瘦及96斤,不然事后再也麻烦顾了,每次在一块的早晚到底觉得时间过得好快,想想这到乃又比方活动,心里淡淡的发愁,不过想到四月份尚会看到就兴奋不已,四月份若就可以看到瘦瘦的我,再为未腻弃我胖了,我如果举行只高颜值的女学霸。

样例

吃有之间距列表 => 合并后底区间列表:

[                     [
  [1, 3],               [1, 6],
  [2, 6],      =>       [8, 10],
  [8, 10],              [15, 18]
  [15, 18]            ]
]

let merge=(intervals) => {
    intervals.sort((a,b)=>{
        //先排序
        if(a[0]!=b[0]){return a[0]-b[0]}
        return a[1]-b[1]
    })
    let len=intervals.length
    let res=[],start,end
    for(let i=0;i<len;i++){
        let s=intervals[i][0],e=intervals[i][1]
        if(!start) {start=s,end=e}
        else if(s<=end){end=Math.max(end,e)}
        else{
            let part=[start,end]
            res.push(part)
            start=s
            end=e
        }
    }
    if(start){
        let part=[start,end]
        res.push(part)
    }
    return res
}
let arr=[
[1,3],[2,6],[8,10],[9,11]]

console.log(merge(arr)) //[1,6],[8,11]

思路:将间隔从深至有些排序,遍历找下个区间中的叠部分,push进新数组

   
今天举行了无数业务,学了车,吃了火锅,学了lol,貌似愚笨的我要尚未学会,被嫌弃的不要不若的,不过琼哥还是充分有耐心,谢谢我的琼哥,虽然我们当合时未添加,不过你对本身的包容我或者亮的,我为是比较自由,一生气你还得耐心的哄我,我也应有改脾气,应该下决心去改变,慢慢改,我眷恋一定能改少的。

样例

n=4,返回 true;

n=5,返回 false.

let checkPowerOf2 = (num) => {
    let decimalRes=num.toString(2)&(num-1).toString(2)
    return num>0&&decimalRes==0
}

思路:位操作,当前勤并上他的上一个反复,如为0尽管是2之幂数

     
以后的路程还蛮丰富,我愿常伴与你,以后如果产生的作业还来很多,我情愿和汝荣辱与同,以后的考验还有众多,我乐意坚持坚持到终极。既然开始了,那即便应该出只全面的后果。就如久,从开头的提神到中途的疲态再到后半程的死撑,但是熬过去,终究会相终点,获得成功。

3.27

      日子非常丰富,两人数带手共同活动。

样例

于定 1->2->3->4,和节点 3,删除 3 之后,链表应该成为
1->2->4。

let deleteNode=(arr,n)=>{
    let pos=arr.indexOf(n)
    arr.splice(pos,1)
return arr
}

思路:因为js中莫指针和链表这点儿独概念,就作为数组来描写,但复杂度不可能是o1。所以解题思路是找到索引,然后去那个元素。

         
今天于同琼哥回来的路上下雪了,说非发出之提神,可能是无比老无看了下雪了,也或是于记忆中,从来没有跟男朋友看了下雪,兴奋的不能自已,突然就想起那句话,下雪的下同不小心就白了条,大概就是最抢的与子偕老的方法。

109.数字三角形

让得一个数字三角形,找到打顶部及脚的极小路径和。每一样步可移动到下一行的附近数字达到。题目链接

212.空格替换

设计同样种方法,将一个字符串中之有着空格替换成 %20
。你可以假设该字符串有足够的长空来在新的字符,且若取的凡“真实的”字符长度。

君的程序还索要返回给调换后底字符串的长短。题材链接

let replaceBlank=(str)=>{
    str=str.replace(/ /g,'%20')
    console.log(str)
    return str.length
}
console.log(replaceBlank("Mr John Smith")) //17

思路:这道题原意是让你整历字符串,然后倒遍历位置。因为js有古已有之措施就是直接用了,that’s
why i love JavaScript deeply~~

3.24

365.二进制中有多少只1

计量以一个 32 位的平头的二进制表式中出微只 1
题材链接

let countOnes=(num)=>{
    let str=num.toString(2)
    let i=0,res=0
    for(;i<str.length;i++){
        if(str.charAt(i)==1){res+=1}
    }
return res
}
console.log(countOnes(7))//3

思路:转换为二进制,遍历

样例

要是将31换为14,需要改变2单bit位。

(31)10=(11111)2

(14)10=(01110)2

let bitSwapRequired=(n1,n2)=>{
    let res=0

    let num1=n1.toString(2)
    let num2=n2.toString(2)
    let maxL=Math.max(num1.length,num2.length)
    let maxN=Math.max(num1,num2),minN=Math.min(num1,num2)
    for(let i=maxL;i>0;i--){
        //maxN和minN都是数字,先转化为字符串再遍历每个位置
        if((''+maxN).charAt(i)!=(''+minN).charAt(i)){res++}
    }
    return res;
}
console.log(bitSwapRequired(19,31)) //2

思路:转化为2进制之后,按照字符串的门类遍历。注意一定是于尾部开始遍历。

166.链表倒数第n单节点

找到单链表倒数第n只节点,保证链表中节点的至少数量为n。题目链接

82.落单的数

给出2*n + 1
只的数字,除中一个数字外其余每个数字均出现些微破,找到这数字。

题材链接

样例
给出 [1,2,2,1,3,4,3],返回 4

function singleNumber(arr){
        arr.sort()
        var totalArr=[]
        for(var i=0;i<arr.length+1;i+=2){
            if(arr[i]!=arr[i+1]){
                if(i==arr.length-1){return arr[i]}//如果arr[i]为最后一个自然数则返回他
                if(arr[i+2]==arr[i+1]){return arr[i]}
            }
        }
    }

圈了产大多数底算法,都是为此各项操作符异或竟的,既然js有sort()方法还是这么写好了,反正都得遍历。

样例

遵n=3,1+1+1=1+2=2+1=3,共发生3遭受不同的章程

返回 3

function climbStairs(n){
    var mtd=0
    if(n==0||n==1){
        return 1
    }
    else{
        mtd=climbStairs(n-1)+climbStairs(n-2)
    }
    return mtd
}

思路:爬至第几层即是高达一样重合在攀登一交汇,也就是达到及等同重叠爬两层···以此类推,递归

397.无比丰富上升连续子序列

吃一定一个整数数组(下标从 0 到 n-1, n
代表整个数组的规模),请找有拖欠数组中之无比丰富上升连续子序列。(最丰富上升连续子序列可以定义也从右到左或从左到右的阵。)题材链接

let res=[],temp=[]
let longestIncreasingContinuousSubsequenc=function(arr,pos){
    if(pos==arr.length-1) {
        if(arr[pos]<arr[pos-1]){res.push(arr[pos])}
        return res
    }
    for(let i=pos;i<arr.length;i++){
        if(temp.length==0){
            temp.push(arr[i])
            return longestIncreasingContinuousSubsequenc(arr,i+1)
        }
        if(i>0&&i<arr.length-1&&arr[i-1]>arr[i]){
        temp.push(arr[i])
        }else{
            if(temp.length>res.length){
                res=temp
                temp=[]
                return longestIncreasingContinuousSubsequenc(arr,i)
            }
        }
    }
    return res
}
let arr=[5, 4, 2, 1, 9,8,7,6,5,4,3,2,9,5,2] // 9,8,7,6,5,4,3,2
console.log(longestIncreasingContinuousSubsequenc(arr,0))

思路:递归。存有数个全局变量,比较频繁组长度,返回长度十分之雅

142.O(1)时间检测2底幂次

之所以 O(1) 时间检测整数 n 是否是 2 的幂次。
题目链接

3.22

样例

给出 1->3->8->11->15->null,2->null, 返回
1->2->3->8->11->15->null。

let mergeTwoLists=(arr1,arr2)=>{
    let res=[].concat(arr1).concat(arr2)
    res.sort((a,b)=>a-b)
    return res
}
let arr1=[1,3,8,11,15]
let arr2=[2]
console.log(mergeTwoLists(arr1,arr2))

思路:连接两独数组,之后排序

408.二向前制求和

让一定两单次迈入制字符串,返回他们之跟(用二进制表示)。有关链接

3.31

157.论断字符串是否没还字符

落实一个算法确定字符串中之字符是否全都唯一出现
问题链接

138.子数组之和

被得一个整数频组,找到与也零星底子数组。你的代码应该归满足要求的子数组的序曲位置以及竣工位置
题目链接

挑战

若不动额外的仓储空间,你的算法该怎么改?

let isUnique=(str) => {
    for(let i=0;i<str.length;i++){
        for(let j=i+1;j<str.length;j++){
            if(str.charAt(i)==str.charAt(j)){
                return false
            }
        }
    }
    return true
}
console.log(isUnique('abcd')) //true

思路:不占存储空间,只能延长运行时。遍历两叠,找到同样的元素就回来false。

140.x的平方根

心想事成 int sqrt(int x) 函数,计算并回到 x 的平方根。
问题链接

挑战

O(n) time, O(1) extra space

let anagram = (str1,str2)=>{
    if(str1.length!=str2.length) return false
    for(let i=0;i<str1.length;i++){
        if(str1.charAt(i)!=str2.charAt(str1.length-1-i))    return false
    }
return true
}
let str1='abcd',str2='cdba'
console.log(anagram(str1,str2)) //true

思路:找对应的职元素是否一致,不同则return false

373.奇偶区划数组

细分一个平头屡屡组,使得奇数在前偶数在后。问题链接

let partitionArray=(arr)=>{
    let i=0,j=arr.length-1
    while(i<j){
        while(arr[i]%2==1){
            i++;
        }
        while(arr[j]%2==0){
            j--;
        }
        if(i<j){
            arr[i]=arr[i]+arr[j]
            arr[j]=arr[i]-arr[j]
            arr[i]=arr[i]-arr[j]
        }
    }
return arr
}

思路:指针一个当头,一个以尾部,当半只指针将要重合的当儿,停止遍历。

样例

sqrt(3) = 1

sqrt(4) = 2

sqrt(5) = 2

sqrt(10) = 3

let sqrtFn = (num) => Math.sqrt(num)

思路:没有思路,内置方法LOL

3.30

3.23

181.将整数A转换为B

假使一旦用整数A转换为B,需要变更有点个bit位?题材链接

样例

a = 11

b = 1

返回 100

let addBinary=(a,b)=>{
    let sum=(a+b+'').split('')
    const len=sum.length
    let i=len-1
    while(i>0){
        if(sum[i]>1){
            if(sum[i]%2==0){
                if(i>=1){
                    sum[i-1]=parseInt(sum[i-1])+1
                }
                sum[i]=0
            }else{ //%2==1
                sum[i-1]=parseInt(sum[i-1])+Math.floor(sum[i])
                sum[i]=1
            }
        }
        i--
    }
    if(sum[0]>1){
            sum.unshift(Math.floor(sum[0]/2))
            sum[1]=sum[1]%2
    }

    return sum.join('')
}
console.log(addBinary(111,10)) //1001

思路:先随10进制相加,然后还遍历每位是否超1,大于1虽说向前头一各加1,以此类推。

407.加一

于一定一个非负数,表示一个数字数组,在该数的功底及+1,返回一个新的数组。

欠数字以轻重缓急进行排列,最酷的累累以列表的太前方。问题链接

let temp=[]
let plusOne=(arr,pos)=>{
if(arr[pos]+1>=10){
    arr[pos]=0
    return plusOne(arr,pos-1)
}else{  
    if(pos<0){
        arr.unshift(1)
    }else{
        arr[pos]+=1
    }
    return arr
}
}
let arr=[1,9,9,9]
console.log(plusOne(arr,arr.length-1)) //2000

思路:怎么想还是故递归逻辑比较清晰,值得注意的一些凡,当pos小于0的当儿,需要以反复组头部unshift(1)。其实这道题可以偷个懒,就是先将数组变成数字加频转换为数组lol。

样例

于如下矩阵:

[
  [1, 2,  3,  4],
  [5, 6,  7,  8],
  [9,10, 11, 12]
]

返回 [1, 2, 5, 9, 6, 3, 4, 7, 10, 11, 8, 12]

let permutationIndex=(arr)=>{
    let res=[arr[0][0]]
    let r=0,c=0 

    let LEN=arr[0].length*arr.length

    for(let i=0;i<LEN;i++){
        while(i<LEN&&r>=1&&c<arr[0].length-1){
            res.push(arr[--r][++c])
        }

        if(i<LEN&&c<arr[0].length-1){
            res.push(arr[r][++c])
        }else if(i<LEN&&r<arr.length-1){
            res.push(arr[++r][c])
        }

        while(i<LEN&&r<arr.length-1&&c>=1){
            res.push(arr[++r][--c])
        }
        if(i<LEN&&r<arr.length-1){
            res.push(arr[++r][c])
        }else if(i<LEN&&c<arr[0].length-1){
            res.push(arr[r][++c])
        }
    }
    return res
}

思路:这个逻辑比前的复杂性多了,而且不好找规律,为啥要放简单修里!!我耶是网上搜的java代码改化js了。。真心笨

80.叫一定一个请勿排序的平头数组,找到中位数。

中位数
中位数是排序后频繁组的中等价值,如果反复组的个数是有时数单,则回排序后数组的第N/2只数。
样例
深受出数组[4, 5, 1, 2, 3], 返回 3

function median(arr){
        var i=arr.length%2==0? arr.length/2:(arr.length+1)/2
        return arr.sort()[i]
    }

样例

给出 [-3, 1, 2, -3, 4],返回[0, 2] 或者 [1, 3].

function subarraySum(arr){
    let res=[],startIndex=0,sum=0,posArr=[]
    for(j=0;j<arr.length;j++){
        for(let i=startIndex;i<arr.length;i++){
        posArr.push(i)
        sum+=arr[i]
        if(sum==0){
            res.push(posArr)
            posArr=[]
            startIndex++
            break;
        }
        }
    }

    return res
}
function startAndEnd(arr){
    let res=[]
    arr.forEach((a) => {
        let subArr=[]
        subArr.push(a[0])
        subArr.push(a[a.length-1])
        res.push(subArr)
    })
    return res
}
let result=startAndEnd(subarraySum([-3, 1, 2, -3, 4]))

思路:有小只元素就遍历几涂鸦,每次遍历时从指针所指元素开始,找到sum为0的元素即退出循环,下次指针指向下一个素

思路

遍历数组,比前的不得了就清空结果往往组,重新push

样例:

按部就班,给来下列数字三角形:

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

由至至底层的卓绝小路径和为11 ( 2 + 3 + 5 + 1 = 11)。

function minimumTotal(arr){
    var sum=0
    arr.forEach(function(a){
        a.sort()
        sum+=a[0]
    })
    return sum
}

思路:遍历数组,将每个子数组排序,取第零只相加

158.少独字符串是更换位词

描绘起一个函数 anagram(s, t)
判断两只字符串是否足以透过转移字母的顺序变成一样的字符串。题材链接

3.10

跟进“删除重复数字”:

设得以允许出现些微不成还用何以处理?

题材链接

function removeDuplicates(arr){
    var i=0
    var duplicateTimes=0
    while(i<arr.length){
        if(arr[i+1]==arr[i]){
            duplicateTimes++
            if(duplicateTimes>2){
                arr.splice(i+1,1)
            }
        }else{
            duplicateTimes=0
            i++
        }
    }
    return arr
}

思路:和上题相比,多加一个断定标准就是ok了,但仍旧是去除一个元素后i不转移

样例

给出”abc”,返回 true

给出”aab”,返回 false

172.刨除元素

为得一个数组和一个价,在原地删除与价值相同的数字,返回新数组的长短。

要素的依次可以改,并且对新的数组不见面有影响

叫您一个带有 m x n 个元素的矩阵 (m 行, n 列), 求该矩阵的之字型遍历。

于您一个饱含 m x n 个因素的矩阵 (m 行, n 列),
求该矩阵的之字型遍历。问题链接

165.合并两独消除序链表

联合两单破序链表题目链接

97.二叉树的最好要命深度

吃得一个二叉树,找来该尽深深度。二叉树的纵深也根本节点到最远叶子节点的去。

题目链接

372.当O(1)时间复杂度删除链表节点

叫得一个单链表中的一个等给删除的节点(非表头或表尾)。请于当O(1)时间复杂度删除该链表节点问题链接

样例

给出同棵如下的二叉树:

  1
 / \ 
2   3
   / \
  4   5

以此二叉树的无比可怜深度为3.

function maxDepth(len){
    if(len%2==0){
        depth++
        return maxDepth(len/2)
    }
    return depth
}

思路:深度也2之n次方-1,传数组的尺寸+1,算几次幂即使好了

3.15

211.字符串置换

具体不说了,和158变换个词一个意思问题链接

样例

于出数组A =[1,1,2],你的函数应该归长度2,此时A=[1,2]。

function removeDuplicates(arr){
    var i=0
    while(i<arr.length){
        if(arr[i+1]==arr[i]){
            arr.splice(i+1,1)
        }else{
            i++
        }
    }
    return arr
}

思路:遍历数组,删除一个元素后无欲改i值

挑战

遍历两不行的法十分易想到,如果只是遍历一不善你闹没有起什么好方式?

function longestWords(arr){
    let maxLen=0,res=[]
    arr.forEach( (a) => {
        if(a.length>=maxLen){
            if(a.length>maxLen){
                maxLen=a.length
                    res=[]
            }
            res.push(a)
        }
    })
    return res
}

3.21

69.给有同棵二交叉树,返回其节点值的层系遍历(逐层从左往右访问)

二叉树的层次遍历
样例
被一样棵二叉树 {3,9,20,#,#,15,7} :

  3
 / \
9  20
  /  \
 15   7

回来外的旁遍历结果:

[
  [3],
  [9,20],
  [15,7]
]

function levelOrder(arr){
        var res=[]
        var tempArr=[]
        var levelNum=1 //每层的节点数
        var levelTotal=1 //层的阶乘
        for(var i=0;i<arr.length+1;i++){
            if(arr[i]=='#'){arr[i]=undefined}
            if(i<levelTotal){
                tempArr.push(arr[i])
            }else if(i==levelTotal){ //等于的时候退出子数组,往res中push
                res.push(tempArr)
                tempArr=[] //清空子数组
                tempArr.push(arr[i])
                levelNum*=2
                levelTotal+=levelNum
            }
        }
        return res
    }

133.尽丰富单词

吃一个词典,找来里面拥有最丰富的单词。
问题链接

185.矩阵的的字型遍历

3.13

96.链表划分

深受得一个单链表和数值x,划分链表使得所有小于x的节点排在超出等于x的节点前。

而应当保留少数有的外链表节点原有的对立顺序。
链接

样例
吃定链表 1->4->3->2->5->2->null,并且 x=3

返回 1->2->2->4->3->5->null

function partition(arr,num){
    var pre=[],post=[]
    for(var i in arr){
        if(arr[i]>=num){
            post.push(arr[i])
        }else{
            pre.push(arr[i])
        }
    }
    return pre.concat(post)
}

样例

受闹一个数组 [0,4,4,0,0,2,4,4],和值 4

返 4 并且4单元素的初数组为[0,0,0,2]

let removeElement=(arr,num)=>{
    let newArr=[]
    arr.forEach((a)=>{
        if(a==num){
            newArr.push(a)
        }
    })
    return newArr.length
}
let arr= [0,4,4,0,0,2,4,4]
console.log(removeElement(arr,4))//4

思路:遍历数组,找到一个符合条件的饶push到新数组

101.去除排序数组中的再度数字 II

样例

给出 s = “abcd”,t=”dcab”,返回 true.
给出 s = “ab”, t = “ab”, 返回 true.
给出 s = “ab”, t = “ac”, 返回 false.

156. 集合区间

于来几闭合区间,合并有重叠的一些。
题材链接

3.14

3.29

3.17

3.20(春分)

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website