每日算法-日更贴

175 阅读2分钟

别让任何人打乱你好不容易调整好的节奏。前段时间一直陷入自我怀疑和自我否定中。一直想弄一弄算法这一块,但是一直觉得自己不太行,坚持不下来。算法小白也想试试,看看自己能不能坚持下来。 这是一个日更贴,每天更新一道算法题。

2022.4.5

【排序】颜色排序

image.png

来源:力扣(LeetCode)

链接:leetcode-cn.com/problems/so…

我的思路

题目比较简单,一趟遍历,开一个额外的数组或者对象来存储

代码

     var sortColors = function (nums) {
            let map = [0, 0, 0];
            for (let i = 0; i < nums.length; i++) {
                map[nums[i]]++
            }
            nums.length = 0;//这里我将nums=[]的时候始终提交不过
            for (let i = 0; i < map.length; i++) {
                for (let j = 0; j < map[i]; j++) {
                    nums.push(i);
                }
            }
        }

遇到一个问题

上面将nums=[] 提交上去死活不能通过。

2022.4.6

【排序】三数之和

image.png 来源:力扣(LeetCode)

链接:leetcode-cn.com/problems/3s…

我的思路

排序 排除不可能的项, 但是还是没有做出来。参考别人的思路

代码

var threeSum = function (nums) {
            debugger
            if (nums.length < 3) {
                return [];
            }

            //先排序
            let sortNums = nums.sort((a,b)=>a-b);
            let arr = [];
            let len = sortNums.length;
            //
            for (let i = 0; i < sortNums.length; i++) {
                if (sortNums[i] > 0) {  //第一个数字大于0 肯定凑不成三元组
                    break;
                }
                //左指针
                let l = i + 1;
                //右指针
                let r = len - 1;
                //如果遇到重复的数字跳过
                if (i > 0 && sortNums[i] == sortNums[i - 1]) {
                    continue;
                }
                while (l < r) { //j是左边的  r为右边的
                    //情况一:三数之和小于0  说明左边负太多了  左边前进
                    if (sortNums[i] + sortNums[l] + sortNums[r] == 0) {
                        arr.push([sortNums[i], sortNums[l], sortNums[r]]);
                        while (sortNums[l] === sortNums[l + 1]) {//如果重复跳过
                            l++;
                        }
                        l++;

                        while (sortNums[r] === sortNums[r - 1]) {//如果重复跳过
                            r--;
                        }
                        r--;
                        continue;

                    } else if (sortNums[i] + sortNums[l] + sortNums[r] > 0) { //情况一:三数之和大于0  说明右边正太多了  右边后退
                        r--;

                    } else {
                        l++;
                    }
                }
            }

            return arr;

        };

总结

看了别人的实现思路,感觉也没有很难吧,可能多练一练就有感觉了,加油!

2022.4.7

【排序】最长递增子序列

image.png 来源:力扣(LeetCode)

链接:leetcode-cn.com/problems/lo…

我的思路

从第二个开始。nums[i]<nums[i-1] 这样不符合递增。记下此时的下标。

代码

var findLengthOfLCIS = function(nums) {
    let maxLength = 0;
    let start = 0;
    for(let i=0;i<nums.length;i++){
        if(i>0&&nums[i]<=nums[i-1]){ //不符合子序列的规则  记下此时的下标
            start=i;
        }
        maxLength = Math.max(maxLength,i-start+1)
    }
    return maxLength;
};

2022.4.9

【排序】最长连续列

image.png 链接:leetcode-cn.com/problems/lo…

我的思路

  • 首先是排序
  • 符合这样一个规则就是连续的nums[i]-nums[i-1]=1
  • 要考虑有重复的情况

代码

 //必须是连着的  说明 nums[i] - nums[i-1]=1
        var longestConsecutive = function (nums) {
            if(!nums.length){
                return 0;
            }
            var sortNums = nums.sort((a, b) => {
                return a - b;
            })
            let len = 1;
            for (let i = 0; i < sortNums.length; i++) {
             
                if (nums[i] == nums[i - 1])
                    continue;
                if (nums[i] == nums[i - 1] + 1) {
                    maxlen++;
                    len = Math.max(len, maxlen);
                }
                else//破坏了连续规则 赋值为1
                    maxlen = 1;
            }

            return len;

        };

2022.4.10

【排序】合并区间

image.png

来源:力扣(LeetCode)

链接:leetcode-cn.com/problems/me…

我的思路

排序 加贪心 然后合并

代码

 //判断是否符合条件
        var isOverlapping = (a, b) => {
            if (a[0] > b[1]) return false;  //排了序之后有这样一个规则 a[0]<a[1]  , a[0] < b[1]这样才满足
            if (a[1] < b[0]) return false; // 不可能有重复的  a[0]<a[1] < b[0]
            return true;

        }
        //合并比较a[0]和b[0]谁比较小就取谁的值   a[1] b[1] 谁的值比较大就去取谁的值
        var mergeArr = (a, b) => {
            let start = Math.min(a[0], b[0]);
            let end = Math.max(a[1], b[1]);
            return [start, end];
        }
        //先做数组排序   按区间的第一个数据来排
        var merge = function (intervals) {
            intervals.sort((a, b) => a[0] - b[0]); //排好序了  
            for (let i = 0; i < intervals.length - 1; i++) {
                if (isOverlapping(intervals[i], intervals[i + 1])) {
                    intervals[i + 1] = mergeArr(intervals[i], intervals[i + 1]);
                    intervals[i] = undefined;
                }

            }
            //在去除为undefined的值
            return intervals.filter(item=>item)

        };

就是效率还有待提高

2022.4.15

【字符串】无重复最长子串

image.png

来源:力扣(LeetCode)

链接:leetcode-cn.com/problems/lo…

我的思路

双重循环

代码

 var lengthOfLongestSubstring = function (s) {
            let ss = '';
            for (let i = 0; i < s.length; i++) {
                let s1 = s[i];
                for (let j = i + 1; j < s.length; j++) {
                    let s2 = s[j];
                    if (!s1.includes(s2)) {
                        //扩充s1
                        s1 = s1 + s2;
                    } else {
                        //相同了 本次不连续重复子串的规则被打破
                        //退出本次循环
                        ss.length < s1.length ? ss = s1 : ss;
                        break;

                    }
                    ss.length < s1.length ? ss = s1 : ss;
                }

            }
            return ss.length;
        }

就是效率还有待提高

2022.4.16

【字符串】最长公共前缀

image.png

来源:力扣(LeetCode)

链接:leetcode-cn.com/problems/lo…

我的思路

排序 ,拿第一个或者最后一个进行比较

代码

  var longestCommonPrefix = function (strs) {
            if (!strs.length) return "";
            //先将字符串排序  最长的可能就是第一个字符串
            let sortStrs = strs.sort((a, b) => {
                return a.length - b.length;
            })

            let str = "";
            //遍历第一个的长度
            for (let i = 0; i < sortStrs[0].length; i++) {
                let comStr = sortStrs[0].slice(0, i+1);
                let isInclude = sortStrs.every(item => {
                    return item.startsWith(comStr);
                })
                if (!isInclude) {
                    break;
                }
                str = comStr;
            }
            return str;

        };

算法小白只会暴力解决,留下来没有技术含量的泪水