面试题汇总

目录

 1.排序：从老到新排序（按照时间戳从老到新的顺序进行排序）

方法一：

2.编写一个函数, 将一维数组结构转换成嵌套的树形结

方法一：使用Map数据结构实现

方法二：

方法三：

---

 1.排序：从老到新排序（按照时间戳从老到新的顺序进行排序）

---

方法一：

<script>

        // 输入数据
        var input = [
            {
                l: [{ id: 1, ts: '2022-09-10' }, { id: 2, ts: '2022-09-19' }]
            },
            {
                l: [{ id: 3, ts: '2022-01-19' }, { id: 4, ts: '2022-03-20' }, { id: 5, ts: '2021-08-22' }]
            },
            {
                l: [{ id: 6, ts: '2019-11-09' }, { id: 9, ts: '2018-03-12' }, { id: 10, ts: '2022-05-11' }, { id: 11, ts: '2022-07-05' }]
            },
            {
                l: [{ id: 7, ts: '2009-11-01' }]
            },
            {
                l: [{ id: 8, ts: '2022-09-28' }, { id: 13, ts: '2022-07-11' }, { id: 12, ts: '2020-03-02' }, { id: 20, ts: '2022-01-05' }, { id: 15, ts: '2022-05-10' }]
            },
        ]
        // 先找到每行最老的时间戳，然后再排序从老到新
        // 需要的输出结果：
        out = [
            { id: 7, ts: '2009-11-01' },
            { id: 9, ts: '2018-03-12' },
            { id: 12, ts: '2020-03-02' },
            { id: 5, ts: '2021-08-22' },
            { id: 1, ts: '2022-09-10' },
        ]


        function sort(input) {
            var timestamps = [];

            // 找到每行最老的时间戳
            input.forEach(obj => {
                var oldestTimestamp = obj.l.reduce((oldest, current) => {
                    if (oldest === null || current.ts < oldest.ts) {
                        return current;
                    }
                    return oldest;
                }, null);

                if (oldestTimestamp) {
                    timestamps.push(oldestTimestamp);
                }
            });

            // 按照时间戳从旧到新的顺序排序
            timestamps.sort((a, b) => a.ts.localeCompare(b.ts));

            var out = [];

            // 在原始输入数据中查找具有相应时间戳的对象，并添加到结果数组中
            timestamps.forEach(timestamp => {
                var foundObj = input.find(obj => {
                    var foundTimestamp = obj.l.find(element => element.ts === timestamp.ts);
                    return foundTimestamp !== undefined;
                });

                if (foundObj) {
                    out.push(foundObj.l.find(element => element.ts === timestamp.ts));
                }
            });

            return out;
        }

        console.log(sort(input));

    </script>

2.编写一个函数, 将一维数组结构转换成嵌套的树形结构

---

 //编写一个函数, 将一维数组结构转换成嵌套的树形结构

        const data = [
            { id: 1, pId: null},
            { id: 2, pId: 1 },
            { id: 3, pId: 1 },
            { id: 4, pId: 2 },
            { id: 5, pId: 2 },
            { id: 6, pId: 3 }
        ]

tree=
       {
            "id":1,
            "child":[
                {
                    "id":2,
                    "child":[
                        {"id":4,"child":[]},
                        {"id":5,"child":[]}
                    ]
                },
                {
                    "id":3,
                    "child":[
                        {"id":6,"child":[]}
                    ]
                }
            ]
        }

    

方法一：使用Map数据结构实现

/* 使用Map数据结构实现 */
    function convertToTree(data) {
        const map = new Map();
        const tree = [];
        for (const node of data) {
            const newNode = { ...node, children: [] };
            map.set(newNode.id, newNode);
            const parent = map.get(newNode.pId);
            if (parent) {
                parent.children.push(newNode);
            } else {
                tree.push(newNode);
            }
        }
        return tree;
    }
    const data = [
        { id: 1, pId: null },
        { id: 2, pId: 1 },
        { id: 3, pId: 1 },
        { id: 4, pId: 2 },
        { id: 5, pId: 2 },
        { id: 6, pId: 3 }
    ];
    const tree = convertToTree(data);
    console.log(tree);

方法二：

/* 方法二 */
    function convertToTree(data) {
        const tree = [];
        const lookup = {};

        // 创建节点
        data.forEach(item => {
            lookup[item.id] = { id: item.id, children: [] };
        });

        // 构建树
        data.forEach(item => {
            const node = lookup[item.id];
            if (item.pId === null) {
                tree.push(node);
            } else {
                const parent = lookup[item.pId];
                parent.children.push(node);
            }
        });

        return tree;
    }

    const data = [
        { id: 1, pId: null },
        { id: 2, pId: 1 },
        { id: 3, pId: 1 },
        { id: 4, pId: 2 },
        { id: 5, pId: 2 },
        { id: 6, pId: 3 }
    ];
    const tree = convertToTree(data);
    console.log(tree);

方法三：

1. function buildTree(data, parentId = null) {
           const child = [];
   
           data.forEach(obj => {
               if (obj.pId === parentId) {
                   const subtree = buildTree(data, obj.id);
                   child.push(subtree);
               }
           });
   
           const node = { id: parentId, child: child };
           return node;
       }
   
       const data = [
           { id: 1, pId: null },
           { id: 2, pId: 1 },
           { id: 3, pId: 1 },
           { id: 4, pId: 2 },
           { id: 5, pId: 2 },
           { id: 6, pId: 3 }
       ]
   
       const treeObj = buildTree(data);
       console.log(JSON.stringify(treeObj));

3.实现json对象的深拷贝

    //递归方法实现深拷贝
    function deepCopy(obj){

        //如果输入的obj不是对象类型，或者为空，就直接返回它本身
        if(typeof obj !== "object" || obj === null){
            return obj;
        }

        let copy;

        //判断obj是否为数组，为数组类型，就循环遍历，递归进行拷贝
        if(Array.isArray(obj)){ 
            copy=[];
            for(let i=0;i<=obj.length;i++){
                copy[i] = deepCopy(obj[i]);
            }
        }else{  //另一种情况：就是obj为json对象
            copy={};
            for(let key in obj){//for in 循环对象的属性key
                if(obj.hasOwnProperty(key)){//判断对象本身上是否有某个属性
                    copy[key] = deepCopy(obj[key]); //如果有这个属性，就把这个属性的值赋给空的对象的这个属性，如果obj的这个属性的值为一个对象，则递归遍历执行原函数
                } 
            }

        }

        return copy;


    }