当前位置:网站首页>力扣+牛客--刷题记录

力扣+牛客--刷题记录

2022-08-10 15:13:00 即将秃头的菜鸟

活动地址:CSDN21天学习挑战赛

 一、字符串中的第一个唯一字符

第一种方法

根据题意是返回字符的索引,所以我没可以把字符串放到数组中,又因为一共有26个字母,所以我没创建一个容量为26的数组把字符串放进去,利用哈希的思想来统计数据,最后看第一个字母数量为1的,返回就行。

    public int firstUniqChar(String s) {
        int[] arr = new int[26];
        char[] chars = s.toCharArray();
        //统计
        for (int i = chars.length - 1; i >= 0; i--) {
            arr[chars[i] - 'a'] = arr[chars[i] - 'a'] + 1;
        }
        //找出第一次出现的字母
        for (int i = 0; i < chars.length; i++) {
            if (arr[chars[i] - 'a'] == 1) {
                return i;
            }
        }
        return -1;
    }

第二种方法

双层循环,一个一个检验。遍历一圈后如果没有和当前待检验的字符相同且下标不同的字符,则输出当前字符下标,否则,继续检验下一个字符,全部检验完后未发现符合条件字符,则输出-1。然后通过continue跳出内层循环,直接开启下一个外层循环。

    public int firstUniqChar(String s) {
        char[] arr = s.toCharArray();
        int i = 0 , len = arr.length;
        label:
        while(i < len){
            for(int j=0; j<len; ++j){
                if(arr[i]==arr[j] && i != j){
                    ++i;  continue label;
                }
            }
            return i;
        }
        return -1;
    }

第三种方法

利用哈希的思想,第一次遍历的时候记录每个字符出现的次数,然后再第二次遍历的时候,只要他对应的value值是一,那么就返回。

    public int firstUniqChar(String s) {
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            map.put(ch, map.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < s.length(); ++i) {
            if (map.get(s.charAt(i)) == 1) {
                return i;
            }
        }
        return -1;
    }

 二、实现strStr() 

思路

我这里的想法很粗暴,就是让字符串 needle 与字符串 haystack 的所有长度为 m 的子串都匹配一次,匹配失败就break,进行下一次匹配。都匹配就返回-1。

    public int strStr(String haystack, String needle) {
        int haylen = haystack.length();
        int needlen = needle.length();
        for (int i = 0; i + haylen <= needlen; i++) {
            boolean flag = true;
            for (int j = 0; j < haylen; j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                return i;
            }
        }
        return -1;
    }

三、存在重复元素

 第一种方法

直接对数组排序,然后判断相邻元素是否相等。

    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == nums[i+1]) {
                return true;
            }
        }
        return false;
    }

第二种方法

利用哈希的思想,因为set里面不允许出现重复的元素,所以直接遍历数组,看数组元素是否以及再set集合中。

    public boolean containsDuplicate(int[] nums) {
        Set<Integer> set = new HashSet<>();
        for (int x : nums) {
            if (!set.add(x)) {
                return true;
            }
        }
        return false;
    }

四、存在重复元素Ⅱ

 思路

这个题和上面那个题没什么不同,也是用哈希的思想,还是利用set,因为一个哈希集合里面最多存在k个元素,如果有重复出现的值,那么就说明再k的距离范围内,存在重复的元素。

    public boolean containsNearbyDuplicate(int[] nums, int k) {
        HashSet<Integer> set = new HashSet<>();
        for(int i = 0; i < nums.length; i++) {
            if(set.contains(nums[i])) {
                return true;
            }
            set.add(nums[i]);
            if(set.size() > k) {
                set.remove(nums[i - k]);
            }
        }
        return false;
    }

五、链表的中间节点

思路

快慢指针,用两个指针 slow与 fast 一起遍历链表。slow 一次走一步,fast 一次走两步。那么当 fast 到达链表的末尾时,slow 必然位于中间。

    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

原网站

版权声明
本文为[即将秃头的菜鸟]所创,转载请带上原文链接,感谢
https://blog.csdn.net/qq_52592775/article/details/126237356