前端算法面试题

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //#region   判断一个字符串中出现次数最多的字符,并统计次数。例如:aaabbbbbbbbbbbbbbbbccccccccccccccccccccc
        // function fun(s) {
        //     let maxNum = 0;
        //     let maxStr = "";
        //     let map = new Map();
        //     for (let item of s) {
        //         map.set(item, (map.get(item) || 0) + 1);
        //     }
        //     console.log(map, 'map')

        //     for (let [key, value] of map) {
        //         if (value > maxNum) {
        //             maxStr = key;
        //             maxNum = value;
        //         }
        //     }

        //     return [maxStr, maxNum];
        // }

        // console.log(fun('aaabbbbbbbbbbbbbbbbcccccccccccccccccccccccccc'));
        //#endregion

        //#region 给你一个整数数组arr,请你帮忙统计数组中每个数的出现次数。如果每个数的出现次数都是独一无二的,就返回true ; 否则返回false
        // var uniqueOccurrences = function(arr) {
        //     const map = new Map();
        //     for (let item of arr) {
        //         if (map.has(item)) {
        //             map.set(item, map.get(item) + 1);
        //         } else {
        //             map.set(item, 1);
        //         }
        //     }

        //     const set = new Set();
        //     for (let [key, value] of map) {
        //         set.add(value)
        //     }
        //     console.log(set, 'set')

        //     return set.size == map.size;
        // }
        // console.log(uniqueOccurrences([1, 2, 2, 1, 1, 3]))
        //#endregion

        //#region  给定两个数组,编写一个函数来计算它们的交集。
        /***
         * 示例 1:
         * 输入:nums1=[1,2,2,1],nums2 = [2,2]
         * 输出:[2]
         * 示例2:
         * 输入:nums1=[4,9,5],nums2=[9,4,9,8,4]
         * 输出:[9,4]
         */
        // var intersection = function(num1, num2) {
        //     let set = new Set(num2);
        //     return [...new Set(num1)].filter((val) => set.has(val));
        // };
        // console.log(intersection([1, 2, 2, 1], [2, 2]));
        //#endregion

        //#region 给定一个整数数组,判断是否存在重复元素。如果存在一值在数组中出现至少两次,函数返回true。如果数组中每个元素都不相同,则返回 false

        // var containsDuplicate = function(nums) {
        //     // let map = new Map();
        //     // for (const x of nums) {
        //     //     if (map.has(x)) {
        //     //         return true;
        //     //     }
        //     //     map.set(x, 1);
        //     // }
        //     // return false;

        //     // 方法二:
        //     let set = new Set();
        //     for (const x of nums) {
        //         if (set.has(x)) {
        //             return true;
        //         }
        //         set.add(x, 1);
        //     }
        //     return false;
        // }

        // console.log(containsDuplicate([1, 2, 3, 1]))
        //#endregion

        //#region  给定一个整数数组
        // nums
        // 和一个整数目标值target,请你在该数组中找出和为
        // 目标值target的那两个整数,并返回它们的数组下标。
        // 你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重
        // 复出现。
        // 你可以按任意顺序返回答案。
        // 示例 1:
        // 输入:nums=[2,7,1115],target=9
        // 输出:[0,1]
        // 解释:因为nums[0]+nums[1]==9,返回[01]

        // var twoSum = function(nums, target) {
        //     let map = new Map();
        //     for (let i = 0; i < nums.length; i++) {
        //         num = target - nums[i];
        //         if (map.has(num)) {
        //             return [map.get(num), i];
        //         }
        //         map.set(nums[i], i)
        //     }
        // }

        // let result = twoSum([2, 7, 1115], 1122);
        // console.log(result)


        //#endregion
        //#region  给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。
        // var reverseList = function(head) {
        //     let prev = null;
        //     let curr = head;
        //     while (curr != null) {
        //         let next = curr.next;
        //         curr.next = prev;
        //         prev = curr;
        //         curr = next;

        //     }
        //     return prev;
        // }

        // console.log(reverseList([1, 2, 3, 4, 5]))

        //#endregion

        //#region 存在一个按升序排列的链表,给你这个链表的头节点head,请你删除所有重复的元素,使每个元素 只出现一次。
        // var deleteDuplicates = function(head) {
        //     if (!head) {
        //         return head;
        //     }
        //     let cur = head;
        //     while (cur.next) {
        //         console.log(cur, 'cu')
        //         if (cur.val == cur.next.val) {
        //             cur.next = cur.next.next;
        //             console.log(cur, 'cu')
        //         } else {
        //             cur = cur.next;
        //         }
        //     }
        //     return cur;
        // }
        // console.log(deleteDuplicates([1, 1, 2]))
        //#endregion

        //#region  链表
        // let a = {
        //     key: 'a'
        // };
        // let b = {
        //     key: 'b'
        // };
        // let c = {
        //     key: 'c'
        // };
        // let d = {
        //     key: 'd'
        // };
        // a.__protos__ = b;
        // b.__protos__ = c;
        // c.__protos__ = d;
        // d.__protos__ = null;
        // console.log(a);

        // function fun() {
        //     return a;
        // }

        // console.log(new fun().__protos__);
        //#endregion
        //#region 简化路径
        // var simplifyPath = function(path) {
        //     let stack = [];
        //     let str = "";
        //     let arr = path.split('/');
        //     arr.forEach(el => {
        //         if (el && el == '..') {
        //             stack.pop();
        //         } else if (el && el != '.') {
        //             stack.push(el);
        //         }
        //         // console.log('/' + stack.join('/'));

        //     });

        //     arr.length ? str = '/' + stack.join('/') : str = '/';
        //     return str;
        // }
        // console.log(simplifyPath('/home/foo/'));
        //#endregion
        //#region  删除字符串中的所有相邻重复项吗?
        // var removeDuplicates = function(s) {
        //     let stack = [];
        //     for (v of s) {
        //         let prev = stack.pop();
        //         if (prev != v) {
        //             stack.push(prev);
        //             stack.push(v);
        //         }
        //     }

        //     return stack.join('')
        // }
        // console.log(removeDuplicates("abbaca"));
        //#endregion
        //#region  有效的括号
        var isValid = function(s) {
            var stack = [];
            for (let i = 0; i < s.length; i++) {
                const start = s[i];
                if (s[i] == '(' || s[i] == "{" || s[i] == "[") {
                    stack.push(s[i]);
                } else {
                    const end = stack[stack.length - 1];
                    if (start == ")" && end == "(" || start == "]" && end == "[" || start == "}" && end == "{") {
                        stack.pop();
                    } else {
                        return false;
                    }
                }
            }
            return stack.length == 0;
        }

        console.log(isValid("()"))
            //#endregion
    </script>
</body>

</html>

你可能感兴趣的:(前端,算法)