前端笔试题

1. 编写一个程序将数组、对象扁平化去并去重（值相同即为重复），最终得到一个升序的数组

例子：var arr = [15, [1, new Number(1), 2], { a: 3, b: [4, 7, 8] }, [6, 7, 8, 9, [11, 12, [12, 13, [14]]]]];

返回： [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 15]

function deepFlat(data){

}

递归：

var arr = [15, [1, new Number(1), 2], { a: 3, b: [4, 7, 8] }, [6, 7, 8, 9, [11, 12, [12, 13, [14]]]]];

function flat(arr, d=1){    
    return d>0?
        arr.reduce(
            (total=[],cur,index,self)=>
                 total.concat(
                    Array.isArray(cur)?
                        flat(cur, d-1)
                        :(Object(cur)===cur)?(
                            flat(Object.values(cur))
                        ):cur
                )
            ,[]
        )
        :arr
    ;
}
function fn(a, b){
    return a-b;
}
function deepFlat(data){
    let ar = flat(data, Infinity);
    let set = new Set(ar);
    return Array.from(set).sort(fn);
}
console.log(deepFlat(arr))

 非递归：

function flatten(arr,d){
    while(arr.some(val=>(Object(val) === val))){
        let newArr = [];
        for(let i=0;i<arr.length;i++){
            let val = arr[i];
            if(Object(val) === val){
                newArr=newArr.concat(...Object.values(val));
            }else{
                newArr.push(val);
            }            
        }
        arr = [].concat(...newArr);
    }  
    return Array.from(new Set(arr)).sort(fn);  
}
console.log(flatten(arr, Infinity))

 

2、根据id，查询树状结构的数据，找到对应id的路径，写一个js 函数实现即可。

var list = [{
    id: "ab",
    children: [{
        id: "ab1",
        children: [{
            id: "ab11",
            children: []
        }]
    },{
        id: "ab2",
        children: []
    }, {
        id: "cd",
        children: [{
            id: "aa",
            children: []
        }, {
            id: "ef",
            children: []
        }]
    }]
}]
function search(list, id){
    let path=[];
    let flag = false;
    
    list.forEach(item=>{
        const deepSearch = (data) =>{     
            if(flag) return;  
            path.push(data.id);  
            // console.log(data.id,flag)
            if(data.id === id){
                flag = true;
            }else if(data.children.length == 0){
                // console.log(data)
                path.pop();
            }else{
                data.children.forEach(sub=>deepSearch(sub))                
                if(!flag) path.pop();
            }                      
        }
        deepSearch(item);
    })
    return flag?path.join('->'):[];
}
console.log(search(list,'ef'))

非递归：

function search1(list,id){
    // let path=Array.from(list);
    // path.reverse();
    let tree=[];
    let path = list.reduceRight((acc,cur)=>acc=[].concat(acc,cur));
    path.forEach(item=>item.parent=0);
    
    while(path.length){
        
        let target = path.pop();
        let parent = target.parent;
        
        tree.push(target.id);
        
        if(target.id == id){
            return tree.join('->');
        }
        if(target.children && target.children.length>0){
            let node = target.children;
            let newNode = node.length==1?node:node.reduceRight((acc,cur)=>acc=[].concat(acc,cur));
            newNode.forEach(item=>item.parent=target.id);
            path=[].concat(path, ...newNode);
            
            target = path[path.length-1];
        }
        
        if(path.length>0 && tree[tree.length-1] === target.id)
        {
            tree.pop();
            let last = path[path.length-1];
            if(last.parent !== parent){
                tree.pop()
            }
            if(last.parent == 0){
                tree=[];
            }
        }
    }
    return '';
}
console.log(search1(list,'ef'))

 

3. 写一个归并排序

// 归并原理：先分递归解数组，然后合并数组

//1.先拆分数组为a,b两个小组，两个小组继续拆分直到每个小组只有一个元素

//2.按照拆分过程合并小组， ==合并两个有序的小组

//3.重复第二步直到剩余一个小组

//先写一个合并两个有序小组的函数

递归：

function merge(a,b)
{
    let i=0;
    let j=0;
    let c = [];
    while(i<a.length && j < b.length){
        if(a[i]<b[j]){
            c.push(a[i]);
            i++;
        }
        if(a[i]>b[j]){
            c.push(b[j]);
            j++;
        }
        if(a[i] == b[j]){
            c.push(a[i]);
            c.push(b[j]);
            i++;
            j++
        }
    }
    if(i<a.length){
        c=[].concat(c,a.slice(i));
    }
    if(j<b.length){
        c=[].concat(c,b.slice(j));
    }
    return c;
}
// let a=[1,10,40];
// let b=[2,4,5,6,7,8,9,22];
// console.log( merge(a,b))

function mergeSort(arr){
    if(arr.length == 1){
        return arr;
    }
    let mid=Math.floor((arr.length)/2);    
    let left=arr.slice(0,mid);
    let right=arr.slice(mid);
    return merge(mergeSort(left), mergeSort(right));
}
let mergeArr=[2,4,5,6,1,10,40,7,8,9,22];

console.log(mergeSort(mergeArr));

 

// 非递归
// 思路：自底向上 1.数组从开始两个相连元素合并排序，2.两个相连有序数组合并，3.直到剩余两个有序数组合并
// mid 从1->Math.floor((arr.length)/2)
function mergeSort1(arr){
    let arrLen = arr.length;
    let mid=Math.floor((arrLen)/2);
    for(let i=1;i<arrLen;i=2*i){
        for(let j=0;j<arrLen;j=(j+2*i))
        {
            let left=arr.slice(j,j+i);
            let right=arr.slice(j+i,j+2*i<arrLen?j+2*i:arrLen);
            let sortArr = merge(left,right);
            
            arr.splice(j,2*i,...sortArr);
        }
    } 
    return arr;
}
console.log(mergeSort1(mergeArr));

 4. s = 'yyayybyyc' => s = 'yya5yyb6yyc7'

str.replace(regexp|substr, newSubStr|function(match, p1, p2, p3, offset, string) )

s = 'yyayybyyc'
console.log( s.replace(/yy([a-z])/g, (...args)=>{
    //console.log(args,0+args[1].charCodeAt()-92);
    return args[0]+(args[1].charCodeAt()-92);
}) );