我的力扣屈辱史（自用）

不试一下怎么知道我不行？

已于 2022-06-10 00:46:58 修改

阅读量173

点赞数

文章标签： leetcode 算法 java

于 2022-05-02 00:57:10 首次发布

本文链接：https://blog.csdn.net/weixin_42700882/article/details/124535717

版权

LeetCode屈辱史记录

拾起好久好久不写的java，连基本输入语句都不会写了…难过了5分钟后准备开始我的leetcode之旅。
随缘做题（这样不对）、菜鸡水平，大佬们不要嘲笑我…

2022-05-01

题目：两数之和
难度：easy
执行成功，耗时119ms
思路：读完题目就想到最最简单但O(N^2)的解法，想了1h后还是没能优化，甚至读题不谨慎漏看“返回数组下标”的字眼…看看这执行时间和内存消耗…任重而道远啊。
在这里插入图片描述
解法一：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] arrResult = null;
        String strResult = null;
        int flag;

        for(int m =0;m<nums.length;m++){
            flag = 0;
            for(int n=m+1;n<nums.length;n++){
                if (nums[m]+nums[n]==target){
                    flag=1;
                    strResult = strResult +","+ n;
                }
            }
            if (flag==1){
                strResult = strResult +","+ m;
            }
        }
        if (strResult!=null){
            String[] arrStrResult = strResult.split(",");
            arrResult = new int[arrStrResult.length-1]; //返回结果数组
            for (int x=1;x<arrStrResult.length;x++) { //首为null就不用放入数组
                arrResult[x-1] = Integer.parseInt(arrStrResult[x]); //返回的是下标
            }
        }
        return arrResult;
    }
}

明个再看看。

2022-05-02

今天早上想到了哈希表法，但把自己绕进去了，没想到KEY/VALUE可以对应下标和值…看过官方解，以下是：

    public static int[] TwoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(target - nums[i])) {
                return new int[]{hashtable.get(target - nums[i]), i};
            }
            hashtable.put(nums[i], i);
        }
        return new int[0];
    }

用时：2ms
思路：以空间换时间。
解释：原O(n^2)复杂在:查找当下值（第一轮循环）、查找差值（第二轮循环），现在用哈希表记录查找过的值，即节省了一次循环。
注意：题干设置可假设一组数组只有一组解，只要解里不重复元素即可。所以一旦遇到解即可输出。
疑惑：containskey底层不也是有一层循环吗？嵌套在for里的话不是O(n^2)吗？anyway，怎么样都比我那破玩意好。

总结：for王是我我是for王。第一题结束。

题目：回文数
难度：easy
执行成功，耗时11ms
思路：看到回文数想到用栈。入栈和出栈每位对应一致就是回文数。这里简化为把数组倒着入栈来当做出栈顺序，来和数组原顺序作比对。
在这里插入图片描述

    public static boolean isPalindrome(int x) {
        char[] array = Integer.toString(x).toCharArray();
        Stack<Character> stack = new Stack<Character>(); //array[n],[n-1],...,[0]
        for(int i=array.length-1;i>=0;i--){
            stack.push(array[i]);
        }
        int j = 0;
        for (char s: stack) {
            if(s!=(array[j])){
                return false;
            }
            j++;
        }
        return true;
    }

2022-05-16

题目：罗马数字转整数
难度：Easy
思路：用队列，先入先出。因为题设默认不会有违法输入，所以这里如果只要有前小后大的，结果只有一种就是后-前。
用最直接的办法暴力解决。。居然还能击败这么多用户？赢麻了…这是真实的吗？
在这里插入图片描述

class Solution {
    public int romanToInt(String s) {
        LinkedList<Integer> linkedList = new LinkedList<>();

        int num = 0;
        for(char c : s.toCharArray()){
            switch(c){
                case 'I':
                    num=1;
                    break;
                case 'V':
                    num=5;
                    break;
                case 'X':
                    num=10;
                    break;
                case 'L':
                    num=50;
                    break;
                case 'C':
                    num=100;
                    break;
                case 'D':
                    num=500;
                    break;
                case 'M':
                    num=1000;
                    break;
            }
            linkedList.add(num);
        }

        int sum = 0;
        int number = 0;
        for (int i = 1;i<linkedList.size();){
            int b = linkedList.get(i);
            int a = linkedList.get(i-1);
            if(a<b){
                number = b-a;
                linkedList.remove();
            }else{
                number = a;
            }
            sum += number;
            linkedList.remove();
        }
        if (linkedList.size()==1) {
            sum += linkedList.get(0);
        }
        return sum;
    }
}

官方答案：一看又发现我在脱裤子放屁。sum的计算可以按照不同的两种情况决定是+还是-…而且不需要用队列入队出队…

class Solution {
    Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
        put('I', 1);
        put('V', 5);
        put('X', 10);
        put('L', 50);
        put('C', 100);
        put('D', 500);
        put('M', 1000);
    }};

    public int romanToInt(String s) {
        int ans = 0;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            int value = symbolValues.get(s.charAt(i));
            if (i < n - 1 && value < symbolValues.get(s.charAt(i + 1))) {
                ans -= value;
            } else {
                ans += value;
            }
        }
        return ans;
    }
}

2022-05-19

题目：最长公共前缀
难度：Easy
思路：想用hashcode做，但是死活没能实现。最后用了最直接的暴力解法。for王是我。
在这里插入图片描述

class Solution {
    public String longestCommonPrefix(String[] strs) {
        String str="";
        if (strs[0].equals("") || strs.length==1){
            return strs[0];
        }
        String minLenStr=strs[0];
        for (int i=1;i<strs.length;i++){
            if(strs[i].equals("")){
                return "";
            }
            if(minLenStr.length()>strs[i].length()){
                minLenStr = strs[i];
            }
        }

        for(int m=0;m<minLenStr.length();m++) {
            for (int i = 0; i < strs.length; i++) {
                if (!minLenStr.substring(m, m + 1).equals(strs[i].substring(m, m + 1))) {
                     return str;
                }
            }
            str += strs[0].substring(m, m + 1);
        }
        return str;
    }
}

参考其他人的代码：这个两两比较，每次比较改变公共前缀后再进行下轮比较的方法不错。
用时1ms,内存消耗：39.5 MB

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0)
            return "";
        String ans = strs[0];
        for (int i = 1; i < strs.length; i++) {
            int j = 0;
            for (; j < ans.length() && j < strs[i].length(); j++) {
                if (ans.charAt(j) != strs[i].charAt(j))
                    break;
            }
            ans = ans.substring(0, j);
            if (ans.equals(""))
                return ans;
        }
        return ans;
    }
}

20220528

题目：有效的括号
难度：Easy
思路：用栈，比较栈顶元素和即将放入元素是否匹配，匹配则取出栈顶元素，不匹配则入栈等待下轮匹配。栈的作用：先入后出，适合比较符号配对问题。

class Solution {
    public boolean isValid(String s) {
        char arrStr[] = s.toCharArray();
        Stack stack = new Stack();

        if (s.equals("") || arrStr[0]==')' || arrStr[0]=='}' || arrStr[0]==']'){
            return false;
        }else {
            stack.add(arrStr[0]);
        }
       for (int i=1;i<arrStr.length;i++){
           if(!stack.isEmpty() && Compare((Character) stack.peek(),arrStr[i])){
           //配对则取出栈顶元素
           //if(Compare((Character) stack.peek(),arrStr[i]){
               stack.pop();
               continue;
           }
           stack.push(arrStr[i]);
       }
       if (stack.isEmpty()){
           return true;
       }else{
           return false;
       }
    }

    //配对方法
    public static boolean Compare(char left,char right) {
        if (left=='(' && right==')'){
            return true;
        }
        if (left=='{' && right=='}'){
            return true;
        }
        if (left=='[' && right==']'){
            return true;
        }
        return false;
    }
}

在这里插入图片描述

20220530

题目：删除有序数组中的重复项
难度：Easy
思路：暴力解法…数组一位位挪，这种肯定存在很多重复循环。瞧瞧这美妙的执行时间…
在这里插入图片描述

class Solution {
    public int removeDuplicates(int[] nums) {
        int length = nums.length;
        if(length==0){
            return 0;
        }
        for(int i=1;i<length;){
            if(nums[i-1]==nums[i]){
                for(int j=i+1;j<length;j++){
                    nums[j-1]=nums[j];
                }
                length--;
                if(length==0){
                    return 0;
                }
            }else{
                i++;
            }
        }
        return length;
    }
}

20220603

题目：移除元素
难度：Easy
思路：如果是要移除的元素，就把这个元素和末位元素交换位置，并且再判断一次，不是移除元素直接判断下一个元素。

在这里插入图片描述

class Solution {
    public int removeElement(int[] nums, int val) {
        if(nums.length==-1){
            return 0;
        }
        int length = nums.length;
        for(int i=0;i<length;){
            if(nums[i]==val){
                int temp = nums[i];
                nums[i] = nums[length-1];
                nums[length-1] = temp;
                length--;
            }else{
                i++;
            }
        }
        return length;
    }
}

20220608

题目：实现 strStr()
难度：Easy
思路：。。。我=for王
咱就是说今个突然燃起了要研读一下底层源码的念头
在这里插入图片描述

class Solution {
    public int strStr(String haystack, String needle) {
        if(needle.equals("")){
            return 0;
        }
        if(haystack.equals("")||haystack.length()<needle.length()){
            return -1;
        }

        char arr1[] = haystack.toCharArray();
        char arr2[] = needle.toCharArray();
        for(int i=0;i<arr1.length;i++){
            if(arr1[i]==arr2[0]) {
                if(arr1.length-i<arr2.length){
                    return -1;
                }
                if(arr2.length==1){
                    return i;
                } else {
                    for (int j = 1; j < arr2.length; j++) {
                        if (arr1[i + j] != arr2[j]) {
                            break;
                        }
                        if (j == arr2.length - 1) {
                            return i;
                        }
                    }
                }
            }
        }
        return -1;
    }
}

20220609

毕业一年了。
很惭愧，以不定时一天一道的速度刷leetcode，我是别想有进步了，但每天做完工作内容就已经不想动脑子了…
很感谢我的初中好友兼同专业大佬，前几天她激励我怎样都不算晚只要勇敢去改变。虽然不常联系，但只要一聊天她总能让我重新充满能量。感谢这份支持伴我左右，我还差些勇气必须寻回！其实很多事情只需要埋头做就好啦，想太多只会觉得难到劝退。

题目：搜索插入位置
难度：Easy
思路：题目要求时间复杂度为 O(log n) ，我就觉得得用二分法。得，今日我是if王。像边缘值的解决我永远合并不进去…

class Solution {
    public int searchInsert(int[] nums, int target) {
        if(nums.length==0){
            return 0;
        }
        int indexA = 0;
        int indexB = nums.length-1;
        if(target<=nums[indexA]){
            return 0;
        }
        if(target==nums[indexB]){
            return indexB;
        }
        if(target>nums[indexB]){
            return indexB+1;
        }
        int middle = (indexA+indexB)/2;
        while(1==1) {
            if(target == nums[middle]){
                return middle;
            }
            if (target < nums[middle]){
                indexB = middle;
            }else{
                indexA = middle;
            }
            middle = (indexA+indexB)/2; //新middle
            if(middle==indexA){    //找不到
                return (indexA+1); //下标+1
            }
        }
    }
}

不试一下怎么知道我不行？

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
我的力扣屈辱史（自用）

LeetCode屈辱史记录拾起好久好久不写的java，连基本输入语句都不会写了…难过了5分钟后准备开始我的leetcode之旅。随缘做题（这样不对）、菜鸡水平，大佬们不要嘲笑我…2022-05-01题目：两数之和难度：easy思路：读完题目就想到最最简单但O(N^2)的解法，想了1h后还是没能优化，甚至读题不谨慎漏看“返回数组下标”的字眼…看看这执行时间和内存消耗…任重而道远啊。解法一：class Solution { public int[] twoSum(int[] nums
复制链接

扫一扫