数据结构与算法题

已于 2022-12-12 13:38:16 修改
阅读量316 收藏
点赞数
分类专栏： js 文章标签： javascript
于 2022-11-25 14:16:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cynl7/article/details/128035747
版权

目录

1. 一个数组旋转 K 步

（1）方法一

（2）方法二

（3）方法三

2.判断一个字符串是否匹配括号

3. 数组创建链表

4.JS 反转单向链表

（1）方法一

（2）方法二

5.两个栈实现一个队列

（1）方法一

（2）方法二

6.链表实现队列

7.二分查找

（1）循环实现

（2）递归

8.寻找一个数组中和为 n 的两个数

（1）常规思路双循环（时间复杂度O(n^2)）

（2）嵌套二分查找，时间复杂度为O(logn)

（3）数组是有序的，利用双指针查找，时间复杂度O(n)

9.二叉搜索树的第k最小值

（1）定义二叉搜索树

（2）二叉搜索树三种遍历实现的代码

（3）求二叉搜索树的第k最小值

10. 求斐波那契数列的第 n 值

（1）递归（时间复杂度为 2^n）

（2）循环（时间复杂度为O(n)）

11.移动0到数组的末尾

（1）循环实现 (时间复杂度为O(n^2))

（2）循环+双指针实现(时间复杂度O(n))

12.获取字符串中连续最多的字符以次数

（1）双循环实现（因为有“跳步”的存在，所以时间复杂度为O(n)）

（2）双指针实现（时间复杂度O（n））

13.用S实现快速排序

14. 获取1-10000之前所有的对称数（回文数）

（1）思路1-使用数组反转、比较

（2）思路2-字符串头尾比较

（3）思路3 生成翻转数

（4）性能分析

15.用 JS 实现数字千分位格式化

（1）用数组实现

（2）字符拆分

（3）数字实现

16.切换字母大小写

（1）正则表达式

（2）通过 SSCII 码判断

总结

        

前言

学习数据结构和算法的记录

1. 一个数组旋转 K 步

（1）方法一

时间复杂度为O(n)

function rotate(arr,k){
    const len = arr.length;
    if(!len || !k) return arr
    //取余数避免重复操作
    const step = Math.abs(k % len);//取绝对值
    for(let i = 0; i< step;i++){
        let n = arr.pop()
        if(n) arr.unshift(n)
    }
    return n
}

（2）方法二

function rotate(arr,k){
    const len = arr.length;
    if(!len || !k) return arr;
    //取余数避免重复操作
    const step = Math.abs(k % len)
    const slice1 = arr.slice(-step)
    const slice2 = arr.slice(0,len - step)
    
    //不会影响原数组
    const slice3 = slice1.concat(slice2)
    return slice3
}

（3）方法三

function rotate (arr,k){
    const len = arr.length
    if(!len || !k) return arr
    
    //取余数避免重复操作
    const step = k % len
    if(step == 0 || isNaN(step)) return arr

    const slice1 = arr.slice(-k)
    const slice2 = arr.slice(0,-k)

    const slice3 = slice1.concat(slice2)
    
    //不会修改原数组
    return slice3
}

2.判断一个字符串是否匹配括号

function isMatch(left,right){
    if(left == '{' && right == '}') return true;
    if(left == '[' && right == ']') return true;
    if(left == '(' && right == ')') return true;
    return false
}

function MatchBracket(str){
    const len = str.length
    if(!len) return true
    const leftSymbol = '{[(';
    const rightSymbol = '}])'
    const stack = []
    for(let i =0 ; i < len ; i++){
        const s = str[i]
           
        //入栈
        if(leftSymbol.includes(s)){
            stack.push(s)
        }else if(rightSymbol.includes(s)){
            const left = stack[ stack.length - 1 ]
            
            //出栈
            if(isMatch(left,s)){
                stack.pop()
            }else{
                return false
            }

        }
    }
    
    return stack.length
    
}

3. 数组创建链表

function creatLinkList(arr){
    const len = arr.length;
    if(!len) return throw new Error('arr is empty')
    let curNode = {
        value : arr[ arr.length -1 ],
    }
    if(len == 1) return curNode
    for(let i = len - 2 ; i >= 0 ; i --){
        curNode = {
            value:arr[i],
            next:curNode
        }
    }
    return curNode
}

4.JS 反转单向链表

（1）方法一

//node 的结构为 {value:1,next:{value:2}}
function reserveLink(node){
    let curNode = null
    let preNode = null
    let nextNode = node;
    while(nextNode){
        if(!preNode){
            delete curNode.next
        }
        if(preNode && curNode){
            curNode.next = preNode
        }
        
        preNode = curNode
        curNode = nextNode
        nextNode = nextNode.next 
        
    }
    curNode.next = preNode
    return curNode
}

（2）方法二

//node 的结构为 {value:1,next:{value:2}}
function reserveLink(node){
    let curNode = {
        value:node.value
    }
    let nextNode = node.next
    while(nextNode){
        curNode =  {
            value ： nextNode.value,
            next:curNode
        }
        nextNode = nextNode.next  
    }
    return curNode
}

5.两个栈实现一个队列

（1）方法一

class MyQueue{
    private stack1 = []
    private stack2 = []
    
    add(n){
        this.stack1.push(n)    
    }
    delete(){
        const stack1 = this.stack1
        const stack2 = this.stack2
        while(stack1.length){
            const n = stack1.pop()
            if(n) stack2.push(n)
        }
        const res = stack2.pop()
        while(stack2.length){
            const n = stack2.pop()
            if(n) stack1.push(n)
        }
        return res || null
    }
    get length(){
        return this.stack1.length
    }
}

（2）方法二

class MyQueue {
    private stack1 = []
    private stack2 = []
    
    add(n){
        this.stack1.push(n)
    }
    delete(){
        const stack1 = this.stack1;
        const stack2 = this.stack2
        //继续吐出上次未吐完的
        if(stack2.length) return stack2.pop()
        while(stack1.length){
            const n = stack1.pop()
            if(n) stack2.push(n)
        }
        let res = stack2.pop()
        return res || null
        
    }
}

6.链表实现队列

class MyQueue{
    private head = null
    private tail = null
    private len = 0
    
    add(n){
        const curNode = {
            value:n,
            next:null
        }
        if(!head) this.head = curNode
        const tailNode = this.tail
        if(tailNode) tailNode.next = curNode
        this.tail = curNode
        this.len ++ 
    }
    delete(){
        const headNode = this.head
        if(headNode == null) return null
        if(len == 0) return null
        
        const val = headNode.value
        this.head = headNode.next
        this.len --

        return val
    }
    
    get length(){
        return this.len
    }
}

7.二分查找

（1）循环实现

function binarySearch(arr,target){
    const len = arr.length
    if(!len) return -1
    
    let startIndex = 0;
    let endIndex = len -1;
    while( startIndex <= endIndex){
        const midIndex = Math.floor((startIndex + endIndex) / 2)
        const midValue = arr[midIndex]
        if(target < midValue){
            //目标值较小，则继续在左侧寻找
            endIndex = midIndex - 1
        }else if(target > midValue){
            //目标值较大，则继续在右侧寻找
            starIndex = midIndex + 1
        }else{
            return midIndex
        }
    }
    
    //找不到目标值时
    return -1
}

（2）递归

function binarySearch(arr,target,startIndex,endIndex){
    const len = arr.length;
    if(!len) return -1
    
    if(!startIndex) startIndex = 0
    if(!endIndex) endIndex = len - 1
    
    //相遇则代表没有找到
    if(startIndex > endIndex) return -1
    
    const midIndex = Math.floor((startIndex + endIndex) / 2)
    const midValue = arr[midIndex]
    if(target < midValue){
        //目标值较小，则继续在左侧寻找
        endIndex = midIndex - 1
        binarySearch(arr,target,startIndex,endIndex)
    }else if(target > midValue){
        //目标值较大，则继续在右侧寻找
        startIndex = midIndex + 1
        binarySearch(arr,target,startIndex,endIndex)
    }else{
        return midIndex
    }
}

8.寻找一个数组中和为 n 的两个数

（1）常规思路双循环（时间复杂度O(n^2)）

function findTwoNunbers(arr,n){
    const res = []
    const len = arr.length
    if(!len) return res
    for(let i = o; i < len -1; i++){
        const n1 = arr[i]
        let flag = false
        for(let j = i + 1; j < len; j ++){
            const n2 = arr[j]
            if(n1 + n2 === n){
                res.push(n1)
                res.push(n2)
                flag = true
                break
            }
        }
        if(flag) break
    }
    return res
}

（2）嵌套二分查找，时间复杂度为O(logn)

function findTwoNumbers(arr,n){
    const res = []
    const len = arr.length
    if(!len) return res
    for(let i = 0; i < len -1; i++){
        const n1 = arr[i]
        const n2 = n - n1
        if(binarySearch(arr,n2)){
            res.push(n1)
            res.push(n2)
            break
        }
    }
    return res
}

（3）数组是有序的，利用双指针查找，时间复杂度O(n)

function findTwoNumbers(arr,n){
    const len = arr.length
    const res = []
    
    if(!len) return res
    
    let i = 0
    let j = len - 1
    while(i < j){
        const n1 = arr[i]
        const n2 = arr[j]
        const sum = n1 + n2
        if(sum > n){
            //如果 sum 比 n 大，则 j 向前移动
            j--
        }else if(sum < n){
            //如果 sum 比 n 小，则 i 向后移动
            i++
        }else{
            res.push(n1)
            res.push(n2)
            break
        }
    }
    return res
}

9.二叉搜索树的第k最小值

前言：二叉搜索树的遍历顺序：前序、中序、后序

（1）定义二叉搜索树

const node ={
    value:5,
    left:{
        value:3,
        left:{
            value:2,
            left:null,
            right:null
        },
        right:{
            value:4,
            left:null,
            right:null
        }
    },
    right:{
        value:7,
        left:{
            value:6,
            left:null,
            right:null
        },
        right:{
            value:8,
            left:null,
            right:null
        }
    }
}

（2）二叉搜索树三种遍历实现的代码

let arr = []
//二叉搜索树 前序遍历 root -> left -> right
function preOrderTraverse(node){
    if(!node) return null
    console.log(node.value)
    arr.push(node.value) 
    preOrderTraverse(node.left)
    preOrderTraverse(node.right)
}
//二叉搜索树 中序遍历(遍历后数据是有序的)  left -> root -> right
function inOrderTraverse(node){
    if(!node) return null
    inOrderTraverse(node.left)
    console.log(node.value)
    arr.push(node.value)
    inOrderTraverse(node.right)
 }
//二叉搜索树后序遍历 left -> right -> root
function postOrderTraverse(node){
    if(!node) return null
    postOrderTraverse(node.left)
    postOrderTraverse(node.right)
    console.log(node.value)
    arr.push(node.value)
}



//前序遍历后结果
preOrderTraverse(node)
//arr 数据为 [5, 3, 2, 4, 7, 6, 8]

//中序遍历后结果
arr = []
inOrderTraverse(node)
//arr 数据为 [2, 3, 4, 5, 6, 7, 8]

//后序遍历后结果
arr =[]
postOrderTraverse(node)
//arr 数据为 [2, 4, 3, 6, 8, 7, 5]

（3）求二叉搜索树的第k最小值

function getKthValue(node,k){
    //二叉树中序循环
    inOrderTraverse(node)
    return arr[k] || null
}

10. 求斐波那契数列的第 n 值

（1）递归（时间复杂度为 2^n）

function fibonacci(n){
    if(n <= 0) return 0
    if(n === 1) return 1
    
    return fibonacci(n - 1) + fibonacci(n - 2)
}

（2）循环（时间复杂度为O(n)）

function fibonacci(n){
    if( n <= 0) return 0
    if( n === 1) return 1
    
    let n1 = 1;// n-1
    let n2 = 0;//n - 2
    let res = 0
    for(let i = 2; i <= n; i++){
       res = n1 + n2

        //记录中间值
        n2 = n1
        n1 = res
    }
    return res
}

11.移动0到数组的末尾

（1）循环实现 (时间复杂度为O(n^2))

function moveZero(arr){
    const len = arr.length
    if(!len || len < 2) return

    let zeroLen = 0
    
    for(let i = 0; i < len - zeroLen; i++){
        if(arr[i] == 0){
            arr.push(0)
            arr.splice(i,1) //这个操作本身就是 O(n)
            zeroLen ++
        }
    }
}

（2）循环+双指针实现(时间复杂度O(n))

//方法一
function moveZero(arr){
    const len = arr.length
    if(!len || len < 2) return 
    
    let i
    let j = - 1;//数组中第一个 0 的下标
    
    for(let i = 0 ; i< len ; i++){
        if(arr[i] == 0 && j < 0){
            //赋值 j 第一个 0 的下标
            j = i
        }
        
        if(arr[i] !== 0 && j >= 0){
            const n = arr[j]
            arr[j] = arr[i]
            arr[i] = n
            j++
        }
    }  
}

//方法二
function moveZero(arr){
    const len = arr.length
    if(!len || len < 2) return
    let j = arr.indexOf(0)
    let i = j + 1
    while(i < len){
        if(arr[i] !== 0){
            arr[j] = arr[i]
            arr[i] = 0
            j++
        }
        i++
    }
}

12.获取字符串中连续最多的字符以次数

（1）双循环实现（因为有“跳步”的存在，所以时间复杂度为O(n)）

function findCountinounsChart1(str){
    const len = str.length
    const res = {
        str:'',
        len:0,
    }
    if(!len) return res
    let tempLen = 0
    for(let i = 0; i < len; i++){
        tempLen = 0
        for(let j = 0; j < len; j++){
            if(str[i] == str[j]){
                tempLen++
            }
            if(str[i] !== str[j] || j == len - 1){
                if(tempLen > res.len){
                    res.len = tempLen
                    res.str = str[i]
                }
                if(i < len - 1){
                    i = j - 1 //跳步，j - 1 是因为下一次进入循环 i++
                }
                break
            }
        }
    }
    return res
}

（2）双指针实现（时间复杂度O（n））

function findCountinounsChart2(str){
    const len = str.length
    const res = {
        str:'',
        len:0
    }
    let tempLen = 0
    let i = 0
    let j = 0
    for(; i < len; i++){
        if(str[i] == str[j]){
            tempLen++
        }
        if(str[i] !== str[j] || i == len - 1){
            if(tempLen > res.len){
                res.len = tempLen
                res.str = str[j]
            }
            tempLen = 0
            if(i < len - 1){
                j = i
                i-- //细节为了下次进入循环i 和 j 保持一致
            }
        }
    }
    return res
}

13.用S实现快速排序

//方法一与方法二时间复杂度统一为O(n*logn)
//方法一，用 splice 实现
function quickSort1(arr){
    const len = arr.length
    if(!len) return arr
    
    const midIndex = Math.floor(len / 2)
    const midValue = arr.splice(midIndex,1)
    
    const left = [] //小于中间值的放在left
    const right = [] //大于中间值的放在right


    //splice 会更改原数组，所以这里需要使用 arr.length
    for(let i = 0; i < arr.length; i++){
        const n = arr[i]
        if(n < midValue){
            left.push(n)
        }else{
            right.push(n)
        }

   }

    return quickSort1(left).concat([midValue],quickSort1(right))
}

//方法二  用 slice 实现
function quickSort2(arr){
    const len = arr.length
    if(!len) return len
    
    const midIndex = Math.floor(len / 2)
    const midValue = arr.slice(midIndex,midIndex + 1)

    const left = []
    const right = []
    
    for(let i = 0; i < len; i++){
        if(i !== midIndex){
            const n = arr[i]
            if(n < midValue){
                left.push(n)
            }else{
                right.push(n)
            }
        }
        
    }
    return quickSort2(left).concat([midValue],quickSort2(right))
}

14. 获取1-10000之前所有的对称数（回文数）

（1）思路1-使用数组反转、比较

function findPalindromeNumbers1(max){
    const res = []
    if(max <= 0) return res
    for(let i = 1; i <= max; i++){
        const s = i.toString()
        if(s == s.split('').reverse().join('')){
            res.push(i)
        }
    }
    return res
}

（2）思路2-字符串头尾比较

function findPalindromeNumbers1(max){
    const res = []
    if(max <= 0) return res
    for(let i = 1; i <= max; i++){
        const s = i.toString()
        const len = s.length
        let startIndex = 0
        let endIndex = len - 1
        let flag = true

        while(startIndex < endIndex){
            if(s[startIndex] !== s[endIndex]){
               flag = false
                break 
           }else{
                startIndex++
                endIndex--
            }
        }
        flag && res.push(i)

    }
    return res
}

（3）思路3 生成翻转数

function findPalindromeNumbers1(max){
    const res = []
    if(max <= 0) return res
    for(let i = 1; i <= max; i++){
       let n = i
       let rev = 0
       while(n > 0){
            rev = rev * 10 + n % 10
            n = Math.floor(n/10)
       } 
        rev == i && res.push(i)
       
    }
    return res
}

（4）性能分析

  1. 思路1 - 看似O(n)，但数组转换，操作都需要时间，所以慢
  2. 思路2 VS 思路3 ，操作数字更快（电脑原型就是计算器）

15.用 JS 实现数字千分位格式化

（1）用数组实现

function format1(n:number):string{
    n = Math.floor(n)
    const s = n.toString()
    const arr = s.split('').reverse()
    return arr.reduce((prev,val,index) =>{
        if(index%3 == 0){
            if(prev){
                return val +','+prev
            }else{
                return val
            }
        }else{
            return val + prev
        }
    },'')
}

（2）字符拆分

function format2(n:number):string{
    n = Math.floor(n)
    const s = n.toString()
    const len = s.length
    let res = ''
    for(let i = len - 1; i >= 0; i++){
        const j = len - i
        if(j % 3 == 0){
            if(i == 0){
                res = s[i] + res
            }else{
                res = ',' + s[i] + res
            }
        }else{
            res = s[i] + res
        }
    }
    return res
}

（3）数字实现

function format3(n:number):string{
    const num = Math.floor(n)
    let format = ''
    while(num > 0){
        let res:number|string = num % 1000
        num = Math.floor(num/1000)
        if(num > 0){
            if(res == 0){
                res = ',000'
            }else if(res < 10){
                res = ',00'+res
            }else if(res < 100){
                res = ',0'+res
            }else if(res < 1000){
                res = ','+res
            }
        }else{
            //小于等于0则说明是最后三位，则无需加千位分隔符
            res = res
        }
        format = res + format
    }
    return format
    
}

16.切换字母大小写

（1）正则表达式

function switchLetterCase1(str:string):string{
    let res = ''
    if(!str.length) return res
    const reg1 = /[a-z]/ //小写字母正则
    const reg2 = /[A-Z]/ //大写字母正则

    for(let i = 0; i < str.length; i++){
        const n = str[i]
        if(reg1.test(n)){
            res = res + n.toLocaleUpperCase()
        }else if(reg2.test(n)){
            res = res + n.toLocaleLowerCase()
        }else{
            res = res + n
        }
    }
    return res
}

（2）通过 SSCII 码判断

function switchLetterCase1(str:string):string{
    let res = ''
    if(!str.length) return res
    for(let i = 0; i < str.length; i++){
        const n = str[i]
        const code = n.charCodeAt(0)
        if(code >= 65 && code <= 90){
            //大写转小写
            res = res + n.toLocaleLowerCase() 
        }else if(code >= 97 && code <= 122){
            //小写转大写
            res = res + n.toLocaleUpperCase()
        }else{
            res = res + c
        }
    }
    return res
}

总结

继续学习

数据结构与算法习题库
27Up的博客
12-26 2万+
第一章  绪论 一．选择题 1．数据结构被形式地定义为（K，R），其中K是①_B_的有限集合，R是K上的②_D_的有限集合。   ①A．算法      B．数据元素    C．数据操作     D．逻辑结构   ②A．操作      B．映象        C．存储         D．关系 2．算法分析的目的是①C，算法分析的两个主要方面是②A。     ①A．找出数据结构的合理性 ...
数据结构与算法面试题80道
m0_54854484的博客
05-27 8961
1.把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \ / \ 4 8 12 16 转换成双向链表 4=6=8=10=12=14=16。 首先我们定义的二元查找树 节点的数据结构如下： struct BSTreeNode{int m_nValue; // value of nodeBSTreeNode *m_pLeft; // left child of nodeBSTreeNo
数组旋转，来来来，走个K步~
胡哥有话说
04-19 283
前言在前端算法面试中，数组是经常被问到的、使用到的。今天我们来看一道经典的前端基础面试题：【数组旋转K步】。首先来看下这个题目，假定存在数组 arr = [1, 2, 3, 4, 5, 6, 7]，旋转 k = 3步，即数组末尾的元素依次进行挪动到数组的前面，即结果为 [5, 6, 7, 1, 2, 3, 4]。题目其实不太难，我们借助这个题目来了解一下算法复杂度（时间复...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法 经典题库练习
liulei952413829的博客
03-09 7466
文章目录一、字符串、时间复杂度与逻辑思维训练1、Z字形变换2、字符串转换整数（atoi）3、字符流中第一个不重复的字符4、小易的英语软件二、指针、数组、链表组合练习5、盛最多水的容器6、删除链表的倒数第N个节点7、最小覆盖子串8、数组中相加和为0的三元组9、矩阵10、shopee的链表笔试题11、顺时针打印矩阵三、二分法12、机器人跳跃问题13、百度春招笔试题14、旋转数组的最小数字四、泛型15、泛型五、二叉树、深度优先搜索16、验证二叉搜索树17、二叉树的最大深度18、二叉树加强训练六、堆、栈、列表19、
数据结构与算法习题总结
wangxiaoer813的博客
07-26 8603
数据结构练习题 习题一绪论 1.1单项选择题 数据结构是一门研究非数值计算的程序设计问题中,数据元素的①（C.逻辑结构）、数据信息在计算机中的②（A.存储关系）以及一组相关的运算等的课程。 ​ ①A．操作对象 Ｂ．计算方法 Ｃ．逻辑结构 Ｄ．数据映象 ​ ②A．存储结构 Ｂ．关系 Ｃ．运算 Ｄ．算法 数据结构DS(DataStruct)可以被形式地定义为DS=（D，R），其中D是① （B.数据元素）的有限集合，R是D上的② （D.关系）有限集合。 ​ ①A．算法 Ｂ．数据元素 Ｃ．数据操作 Ｄ．数
数据结构算法题总汇
m0_47954009的博客
10-25 1687
2021年10月25日数组练习 题目一：leetcode136.只出现一次的数字 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于⌊ n/2 ⌋的元素。 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/majority-element 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 题解思路： 1.拿到题目后第一反应是借..
数据结构与算法期末复习——知识点+题库
软件手的博客
05-12 9829
大学生 数据结构期末复习——知识点+题库 四川轻化工
考研数据结构算法题总结
热心上单小张的博客
10-18 5518
考研数据结构100天 Day1：在带头结点的单链表L中，删除所有值为X的节点，并释放其空间，假设值为的X节点不唯一，试编写算法以实现上述操作 void Del-X(LinkList &L,int x){ LNode *p=L->next; LNode *pre=L; LNode *q; while(p!=NULL){ if(p->data==x){ q=p; p=p->next; pre->next=p; free(q); }else{
数据结构KMP算法配图详解（超详细）
weixin_46007276的博客
02-18 21万+
前言 KMP算法是我们数据结构串中最难也是最重要的算法。难是因为KMP算法的代码很优美简洁干练，但里面包含着非常深的思维。真正理解代码的人可以说对KMP算法的了解已经相当深入了。而且这个算法的不少东西的确不容易讲懂，很多正规的书本把概念一摆出直接劝退无数人。这篇文章将尽量以最简单的方式介绍KMP算法以及他的改进，文章的开始我先对kmp算法的三位创始人Knuth,Morris,Pratt致敬，懂得这...
架构师面试中常见的数据结构与算法题（60题）.zip分享给需要的同学
最新发布
09-14
架构师面试中常见的数据结构与算法题（60题）.zip分享给需要的同学
PTA-数据结构与算法题目集.zip
12-28
PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 PTA-数据结构与算法题目集 ...
《数据结构与算法》课后习题答案(课件).pdf
10-31
"数据结构与算法"课后习题答案 《数据结构与算法》课后习题答案是一份关于数据结构和算法的习题答案文档。该文档涵盖了多个方面的知识点，包括线性表、顺序存储结构、链式存储结构、单链表、静态链表、算法设计等。...
数据结构与算法分析（Java语言描述）习题答案（第三版）.docx
06-24
在《数据结构与算法分析（Java语言描述）》（第三版）这本教材中，我们看到涉及了关于数据结构、算法以及程序设计的基础概念。在给出的文档中，部分题目和答案涵盖了递归、数学推理、文件处理以及计算理论等多个方面...
jq及html通过url下载文件
cynl7的博客
12-12 2万+
一、通过html的a标签下载 <a href="url 302到下载地址" download>下载</a> 例如： var link = document.createElement('a')； link.setAttribute("download", ""); link.href = data.fileUrl; link.click(); 二、通过form表...
关于input type="file"表单提交及文件流的动态赋值
cynl7的博客
09-25 1万+
我们都知道，html5中有个input type=file元素。用该元素可以实现页面上传文件的功能 。 页面上写一个input,然后选择一个文件，打印这个input对象 $('.up-file').on('change',function(e){ //上传 console.log( e.currentTarget) }) input的选择的文件被记录到了这个对象中，这个是fi...
element-UI table文字超出两行，隐藏多余文字，移入显示tips
cynl7的博客
03-23 1292
css样式 //写在scoped里面所以需要deep,app-container为el-table外部包裹div的classname .app-container /deep/.el-table .myNoteBox .cell { display: -webkit-box; overflow: hidden; -webkit-line-clamp: 2; -webkit-box-orient: vertical; white-space: normal; } html代码 &
jq事件绑定
cynl7的博客
04-04 925
一、jquery为多个选择器绑定同一个事件 $("#start,#end").on("click",function(){ 　　alert("The paragraph was clicked."); }); 二、多事件绑定同一个选择器 $("p").on("mouseover mouseout",function(){ $("p").toggleClass(&quot
React之 Context跨级组件传值
cynl7的博客
12-30 456
组件跨层级通信-Context 在一个典型的React项目中，数据是通过props属性自上而下的(由父及子)进行传递，但是这种做法对于某些类型的属性而言是极其繁琐的(例如：地区偏好，UI主题)，这些属性是应用程序中许多组件都需要的。Context提供了一种在组件之间共享此类值的方式，而不必显示地通过组件树的逐层传递props 具体使用方法 首先下载React脚手架，并搭建好目录 第一步在src文件夹下创建utils文件夹，并创建ThemeContext.js文件，以及其他组件 3.在ThemeC
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值