【Leecode笔记】第十六周上（12.21-12.25）哈希表专题

最新推荐文章于 2021-12-21 10:01:25 发布
最新推荐文章于 2021-12-21 10:01:25 发布
阅读量187 收藏
点赞数
分类专栏： Leecode 文章标签： java hashmap leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40335368/article/details/111468690
版权

【第一题】独一无二的出现次数

在这里插入图片描述

分析：
方法1：构建哈希表<Integer,Integer>，表示出现次数与元素的映射。将出现次数假如集合，假如有相同的元素在集合中，就会添加失败

public boolean uniqueOccurence(int[] arr){
	Map<Integer,Integer> map = new HashMap<>();
	for(int i = 0;i < arr.length;i++){
		map.put(arr[i],map.getOrDefault(arr[i],0)+1);
	}
	Set<Integer> set = new HashSet<>();
	for(int value:map.values()){
		if(!set.add(value))
			return false;
	}
	return true;
}

方法2：记录value,然后将value改为0，再去看map中有没有匹配的。

//执行用时：2 ms, 在所有 Java 提交中击败了87.80% 的用户
//内存消耗：36.4 MB, 在所有 Java 提交中击败了54.51% 的用户
class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < arr.length;i++){
            map.put(arr[i],map.getOrDefault(arr[i],0)+1); 
        }
        for(int i : map.keySet()){
            int tmp = map.get(i);
            map.put(i,0);
            //System.out.println(map);
            //System.out.println(tmp);
            if(map.containsValue(tmp)){
                return false;
            }
        }    
        return true ;
    }
}

【第二题】存在重复元素

在这里插入图片描述

分析：
方法一：直接用HashSet判重。
方法二：哈希映射

//执行用时：8 ms, 在所有 Java 提交中击败了55.15% 的用户
//内存消耗：44.4 MB, 在所有 Java 提交中击败了46.24% 的用户
class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashSet<Integer> set = new HashSet<Integer>();
        for(int i = 0;i < nums.length;i++){
            if(!set.contains(nums[i])){
                set.add(nums[i]);
            }else{
                return true;
            }
        }
        return false;
    }
}
//____________________________________________________
//执行用时：5 ms, 在所有 Java 提交中击败了76.63% 的用户
//内存消耗：42.5 MB, 在所有 Java 提交中击败了78.03% 的用户
class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashSet<Integer> set = new HashSet<Integer>();
        for(int i = 0;i < nums.length;i++){
            if(!set.add(nums[i])){
                return true;
            }
        }
        return false;
    }
}

//哈希咋嫩个慢？
//执行用时：17 ms, 在所有 Java 提交中击败了6.24% 的用户
//内存消耗：44.1 MB, 在所有 Java 提交中击败了56.26% 的用户
class Solution{
    public boolean containsDuplicate(int[] nums){
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
            if(map.get(nums[i])>1){
                return true;
            }
        }
        return false;
    }
}

【第三题】重复N次的元素

在这里插入图片描述

分析：跟上边那题没啥差别。
方法一：依然哈希集

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：39.3 MB, 在所有 Java 提交中击败了69.92% 的用户
class Solution {
    public int repeatedNTimes(int[] A) {
        HashSet<Integer> set = new HashSet<>();
        for(int i = 0;i < A.length;i++){
            if(!set.add(A[i])){
                return A[i];
            }
        }
        return 0;
    }
}

【第四题】最长回文串

在这里插入图片描述

分析：遍历字符串；
假如字母出现次数>=2:
1.刚好为偶数，sum += count；
2.为奇数，sum=sum+count-1;
假如有字母只出现一次：
sum+=1;(回文串允许有一个不同的字母放在中间)

实现：首先构造哈希表，key为字符串中的字符，Value为字符出现的次数。

class Solution {
    public int longestPalindrome(String s) {
        int sum = 0;
        int flag = 0;
        HashSet<Character> set  = new HashSet<>();
        for(char c:s.toCharArray()){
            set.add(c);
        }
        if(set.size() == 1){
            return s.length();
        }
        HashMap<Character,Integer> map= new HashMap<>();
        for(int i = 0;i < s.length();i++){
            map.put(s.charAt(i),map.getOrDefault(s.charAt(i),0)+1);
        }
        for(char c:map.keySet()){
        //假如是偶数，那么可以直接加入回文串
            if(map.get(c) % 2 == 0){
                sum+=map.get(c);
            }else{
            	//假如数量大于2，可以将偶数部分加入回文串
                if(map.get(c) > 2){
                    if(flag == 0){
                        sum=sum+map.get(c);
                        flag = 1;
                    }else{
                        sum=sum+map.get(c)-1;
                    }
                }
                if(map.get(c) == 1){
                    if(flag == 0){
                        sum +=1;
                        flag = 1;
                    }
                }
            }
        }
        return sum;
    }
}

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：37 MB, 在所有 Java 提交中击败了31.31% 的用户
class Solution{
    public int longestPalindrome(String s){
        int[] cnt = new int[58];
        for(char c:s.toCharArray()){
            cnt[c - 'A']+=1;
        }
        int ans = 0;
        for(int x:cnt){
            //x&1判断奇偶
            ans+=x-(x&1);
        }
        //只允许一个奇数次加入
        return ans < s.length()? ans+1:ans;
    }
}

【第五题】最长和谐子序列

在这里插入图片描述

分析：
方法一：首先建立哈希表，key为数组中的各个数字，value为各个数字出现的次数。
遍历哈希表的keySet，假如存在i+1的key,（也就是说刚好和当前的key相邻），那么把他们的出现次数相加，要是不存在，那说明和谐数组不包括他俩。

方法二：先将数组排序，然后根据元素大小设定一个窗口(由两个指针构成)，窗口中的key之差不超过1.

//执行用时：19 ms, 在所有 Java 提交中击败了83.01% 的用户
//内存消耗：39.8 MB, 在所有 Java 提交中击败了43.34% 的用户
class Solution {
    public int findLHS(int[] nums) {
        int max = 0;
        int count = 0;
        if(nums.length == 0){return 0;}
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
        }
        for(Integer i:map.keySet()){
            if(map.containsKey(i+1)){
                count = map.get(i)+map.get(i+1);
            }else{
                count = 0;
            }
            max = Math.max(max,count);
        }
        return max;
    }
}

//执行用时：16 ms, 在所有 Java 提交中击败了90.10% 的用户
//内存消耗：39 MB, 在所有 Java 提交中击败了97.87% 的用户
class Solution {
    public int findLHS(int[] nums) {
        Arrays.sort(nums);
        int begin = 0,res = 0;
        for(int end = 0;end < nums.length;end++){
            while(nums[end] - nums[begin] > 1)
                 begin++;
            if(nums[end] - nums[begin] == 1)
              res = Math.max(res,end - begin + 1);
        }
        return res;
    }
}

【第六题】有效的字母异位词

在这里插入图片描述

分析：
方法一：直接在同一个哈希表上操作，一个+，一个-。
方法二：两个哈希表，比较各个字母的个数。

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        Map<Character, Integer> table = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            table.put(ch, table.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < t.length(); i++) {
            char ch = t.charAt(i);
            table.put(ch, table.getOrDefault(ch, 0) - 1);
            if (table.get(ch) < 0) {
                return false;
            }
        }
        return true;
    }
}

【第七题】第一个只出现一次的字符

在这里插入图片描述

分析：先遍历一次存入哈希表，key为字符，value为字符出现的次数，然后再遍历一次查找该字符出现的次数，直接输出次数为1的字符。
不行，不行！因为哈希表是无序的。还是得老老实实遍历数组。

//执行用时：35 ms, 在所有 Java 提交中击败了23.57% 的用户
//内存消耗：39 MB, 在所有 Java 提交中击败了56.53% 的用户
class Solution {
    public char firstUniqChar(String s) {
        //if(s.equals("")){return ' ';}
        if(s.length() == 1){return s.charAt(0);}

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

优化：原本是统计每个字符的次数，现在将哈希表的value改成Boolean。

//执行用时：26 ms, 在所有 Java 提交中击败了59.88% 的用户
//内存消耗：38.8 MB, 在所有 Java 提交中击败了81.87% 的用户
class Solution{
	public char firstUniqChar(String s){
		HashMap<Character,Boolean> map = new HashMap<>();
		char[] sc = s.toCharArray();
		for(char c : sc){
			map.put(c,!containsKey(c));
		}
		for(char c:sc){
			if(map.get(c)){return c;}
		}
		return ' ';
	}
}

【第八题】查找常用字符

在这里插入图片描述

分析：
方法一：数组迭代求交集；
方法二：给字符串中的每个字符建立一个哈希表，表示字符和出现次数的映射关系。求各个字符串的交集。
递归求交集。

//执行用时：8 ms, 在所有 Java 提交中击败了39.33% 的用户
//内存消耗：38.8 MB, 在所有 Java 提交中击败了25.72% 的用户
class Solution{
    public List<String> commonChars(String[] A){
        List<String> list = new ArrayList<>();
        //res存放交集
        int[] res = new int[26];
        for(char c:A[0].toCharArray()){
            res[c-'a']++;
        }
        for(int i = 1;i < A.length;i++){
            int[] temp = new int[26];
            for(char c:A[i].toCharArray()){
                temp[c-'a']++;
            }
            for(int j = 0;j < 26;j++){
                //这里取min好妙啊
                res[j] = Math.min(res[j],temp[j]);
            }
        }
        //将结果数组中的元素放入列表
        for(int i = 0;i < res.length;i++){
            if(res[i] > 0){
                for(int j = 0;j < res[i];j++){
                    list.add((char)('a'+i)+"");
                }
            }
        }
        return list;
    }
}

【第九题】员工的重要性（挖坑，搜索图的时候再做）

在这里插入图片描述

分析：主要有几步：1.找员工ID，记录重要度；2.找其下属；3.找下属ID；4.累加下属重要度。
确定数据结构：一对多（树？）

方法一：递归

【第十题】单词规律

在这里插入图片描述

分析：也就是说，str中的各个单词之间的规律是否符合pattern的规律。
方法一：直接替换呗，例如示例1，用a来代替str中的dog，用b来代替cat。
方法二：哈希表+哈希集
方法三：一个哈希表，利用了同一个位置的value，比较put的key是否相同。
方法四：一个哈希表，利用了"第n次put返回第n-1次的value"

//执行用时：1 ms, 在所有 Java 提交中击败了98.94% 的用户
//内存消耗：36.5 MB, 在所有 Java 提交中击败了66.37% 的用户
class Solution {
    public boolean wordPattern(String pattern, String s) {
        //将s按照空格分割成数组,个数不同返回false
        String[] str = s.split(" ");
        if(pattern.length() != str.length){
            return false;
        }
        //哈希集去重：种类数目不同返回false
        HashSet<Character> set1 = new HashSet<>();
        HashSet<String> set2 = new HashSet<>();
        for(int a = 0;a < pattern.length();a++){
            set1.add(pattern.charAt(a));
            set2.add(str[a]);
        }
        if(set1.size()!=set2.size()){
            return false;
        }

        //哈希表：str中单词和pattern中的字符的映射
        Map<Character,String> map = new HashMap<>();
        //i指向pattern的每个字符,j指向s的每个单词
        int i = 0,j = 0;
        while(i < pattern.length() && j < str.length){
            if(map.containsKey(pattern.charAt(i))){
                if(!map.get(pattern.charAt(i)).equals(str[j])){
                    //System.out.println(pattern.charAt(i)+" "+map.get(pattern.charAt(i))+" "+str[j]);
                    return false;
                }
            }else{
                map.put(pattern.charAt(i),str[j]);
            }
            i++;
            j++;
        }
        return true;
    }
}

//执行用时：1 ms, 在所有 Java 提交中击败了98.94% 的用户
//内存消耗：36.3 MB, 在所有 Java 提交中击败了91.16% 的用户
public boolean wordPattern(String pattern,String s){
	String[] strings = s.split(" ");
	if(pattern.length()!=strings.length){
		return false;
	}
	HashMap<Object,Integer> hashMap = new HashMap<>();
	for(int i = 0;i < pattern.length();i++){
	//同一个value，比较两次放进去的key是否一样
		if(!Objects.equals(hashMap.put(pattern.charAt(i),i),hashMap.put(strings[i],i))){
			return false;
		}
	}
	return true;
}

class Solution{
	public boolean wordPattern(String pattern,String s){
		String[] strs = s.split(" ");
		if(pattern.length()!=strs.length){
			return false;
		}
		Map map = new HashMap<>();
		for(Integer i = 0;i < pattern.length();i++){
			//利用map.put方法的返回值(key第一次put的时候返回null,第n次put则返回第n-1次的value)
			if(map.put(pattern.charAt(i),i)!=map.put(strs[i],i)){
				return false;
			}
		}
		return true;
	}
}

【第十一题】强整数

在这里插入图片描述

分析：哈希表标记。

//执行用时：1 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：36.2 MB, 在所有 Java 提交中击败了82.83% 的用户
class Solution {
    public List<Integer> powerfulIntegers(int x, int y, int bound) {
        /*
        题目给定 x 与 y 都大于 0，因此不存在为 0 的情况
        需要注意的点：
        x 或 y 为 1 的时候，那么它的任何次幂都是 1 ，那么只需要计算一次即可
        任何数的 0 次幂都是 1，因此计算时从 1 开始
        */
        Set<Integer> set = new HashSet<>();

        /*
        使用 a 记录 x 的 n 次幂
        使用 b 记录 y 的 n 次幂

        外层循环结束条件 a < bound，即 x 的 n 次幂最多等于 bound - 1，因为 y 的 n 次幂最少为 1
        内层循环结束条件 a + b <= bound，即 两数的幂之和超过 bound 时就退出

        两个 break 
        若 y == 1,因为它的任何次幂都是 1，那么我们内层循环 a 只需要与 它 计算一次即可
        若 x == 1 同理，只需要外层只需要计算一次即可，所有可能都在内层进行计算了
        */
        for(int a = 1; a < bound; a *= x){
            for(int b = 1; a + b <= bound; b *= y){
                set.add(a + b);
                if(y == 1) break;
            }
            if(x == 1) break;
        }
        return new ArrayList<>(set);
    }
}

【第十一题】Bigram分词

在这里插入图片描述

分析：设置双指针.

//执行用时：1 ms, 在所有 Java 提交中击败了75.37% 的用户
//内存消耗：36.8 MB, 在所有 Java 提交中击败了56.62% 的用户
class Solution {
    public String[] findOcurrences(String text, String first, String second) {
        int i = 0,j = 1;
        String[] str = text.split(" ");
        List<String> con = new ArrayList<>();
        while(j < str.length-1){
            if(str[i].equals(first) && str[j].equals(second)){
                con.add(str[j+1]);
                i+=2;
                j+=2;
            }else{
                i++;
                j++;
            }
        }
        return con.toArray(new String[con.size()]);
    }
}

【第十二题】键盘行

在这里插入图片描述

分析：

//执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户
//内存消耗：36 MB, 在所有 Java 提交中击败了99.06% 的用户
class Solution {
    public String[] findWords(String[] words) {
        List<String> list = new ArrayList<>();
        for(String word : words){
            int first = getLine(word.charAt(0));
            boolean flag = true;
            for(int i = 1; i < word.length(); i++){
                if(getLine(word.charAt(i)) != first){
                    flag = false;
                    break;
                }
            }
            if(flag)
                list.add(word);
        }
        return list.toArray(new String[list.size()]);

    }

    public int getLine(char c){
        char ch = Character.toLowerCase(c);
        if("qwertyuiop".indexOf(ch) != -1)
            return 1;
        else if("asdfghjkl".indexOf(ch) != -1)
            return 2;
        else
            return 3;
    }
}

【第十三题】存在重复元素II

在这里插入图片描述

分析：这里感觉题目有歧义，绝对值至多为k，那么假如出现多个值相等，他们的索引有的大于k有的小于k怎么算？
还是说所有可能的值，他们的索引差最多为k？

构建哈希表，key为数组中的值，value为每个值对应的索引

在这里插入图片描述

有点慢，但是想法还不错。

//执行用时：16 ms, 在所有 Java 提交中击败了32.37% 的用户
//内存消耗：47.2 MB, 在所有 Java 提交中击败了5.06% 的用户
class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer,List<Integer>> map = new HashMap<>();
        
        for(int i = 0;i < nums.length;i++){
            if(map.containsKey(nums[i])){
                int cha = Math.abs(i - map.get(nums[i]).get(0));
                if(cha <= k){
                    return true;
                }else{
                    map.get(nums[i]).set(0,i);
                }
            }else{
                map.put(nums[i],new ArrayList<Integer>());
                map.get(nums[i]).add(i);
            }
        }
        return false;
    }
}

上边可以优化，不用list，直接就和map.get(nums[i])比较即可。
同一个代码提交几次执行时间都不同…
在这里插入图片描述

class Solution {
    public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        
        for(int i = 0;i < nums.length;i++){
            if(map.containsKey(nums[i])){
                int cha = Math.abs(i - map.get(nums[i]));
                if(cha <= k){
                    return true;
                }else{
                    map.put(nums[i],i);
                }
            }else{
                map.put(nums[i],i);
            }
        }
        return false;
    }
}

【第十四题】子域名访问计数

在这里插入图片描述

分析：假如说[“900 google.mail.com”]，其中google.mail.com肯定是访问了900次，mail.com访问的次数是包含这个域名的所有域名访问次数之和，.com也是包含这个域名的所有域名访问次数之和。

//执行用时：23 ms, 在所有 Java 提交中击败了63.67% 的用户
//内存消耗：39.5 MB, 在所有 Java 提交中击败了66.05% 的用户
class Solution {
    public List<String> subdomainVisits(String[] cpdomains) {
        Map<String,Integer> map = new HashMap<>();
        for(String str:cpdomains){
            String[] strings = str.split(" ");
            int num = Integer.parseInt(strings[0]);
            String[] sub = strings[1].split("\\.");

            StringBuilder builder = new StringBuilder();
            for(int i = sub.length -1;i >=0;i--){
                if(builder.length() !=0){
                    builder.insert(0,".");
                }
                builder.insert(0,sub[i]);

                String current = builder.toString();
                int value = map.getOrDefault(current,0);
                map.put(current,value+num);
            }
        }
        return map.entrySet().stream().map(x->x.getValue() + " "+x.getKey()).collect(Collectors.toList());
    }
}

【第十五题】分糖果

在这里插入图片描述

//执行用时：37 ms, 在所有 Java 提交中击败了84.14% 的用户
//内存消耗：40.4 MB, 在所有 Java 提交中击败了72.22% 的用户
class Solution {
    public int distributeCandies(int[] candyType) {
        int sum = candyType.length;
        int count = 0;
        HashSet<Integer> set = new HashSet<>();
        for(int i :candyType){
            set.add(i);
        }
        return Math.min(set.size(),sum/2);
    }
}

【第十六题】同构字符串

在这里插入图片描述

分析：
和第十题单词规律有点像
方法一：哈希集去重+哈希表映射
方法二：哈希表映射，value判重
方法三：根据两次映射的
方法四：根据

//执行用时：15 ms, 在所有 Java 提交中击败了31.79% 的用户
//内存消耗：38.6 MB, 在所有 Java 提交中击败了53.61% 的用户
class Solution {
    public boolean isIsomorphic(String s, String t) {
        
        if(s.length()!=t.length()){return false;}

        HashSet<Character> set1 = new HashSet<>();
        HashSet<Character> set2 = new HashSet<>();
        for(int i = 0;i < s.length();i++){
            set1.add(s.charAt(i));
            set2.add(t.charAt(i));
        }
        if(set1.size() != set2.size()){
            return false;
        }

        Map<Character,Character> map = new HashMap<>();
        for(int i = 0;i < s.length();i++){
            if(!map.containsKey(s.charAt(i))){
                map.put(s.charAt(i),t.charAt(i));
            }else{
                if(map.get(s.charAt(i))!=t.charAt(i)){
                    return false;
                }
            }
        }
        return true;
    }
}

//执行用时：12 ms, 在所有 Java 提交中击败了57.32% 的用户
//内存消耗：38.5 MB, 在所有 Java 提交中击败了60.08% 的用户
class Solution {
    public boolean isIsomorphic(String s, String t) {
        if(s.length() != t.length()){
            return false;
        }
        
        HashMap<Character, Character> map = new HashMap<>();
        for(int i=0; i<s.length(); i++){
            if(!map.containsKey(s.charAt(i))){
                if(map.containsValue(t.charAt(i))){
                    return false;
                }
                map.put(s.charAt(i), t.charAt(i));
            }else{
                if(map.get(s.charAt(i))!=t.charAt(i)){
                    return false;
                }
            }
        }
        
        return true;
    }
}

【第十七题】最短补全词

在这里插入图片描述

分析：将牌照中的字母提取，然后排序，和words中的每个单词（排好序）比较，设置两个指针，一个指向牌照中的字母（指针i），一个指向words中单词的字母(指针j)，相等则双双往前，否则只有j往前，统计个数。

“1s3 PSt”
[“step”,“steps”,“stripe”,“stepple”]
“1s3 456”
[“looks”, “pest”, “stew”, “show”]
“Ah71752”
[“suggest”,“letter”,“of”,“husband”,“easy”,“education”,“drug”,“prevent”,“writer”,“old”]
“OgEu755”
[“enough”,“these”,“play”,“wide”,“wonder”,“box”,“arrive”,“money”,“tax”,“thus”]

//执行用时：4 ms, 在所有 Java 提交中击败了78.96% 的用户
//内存消耗：38.8 MB, 在所有 Java 提交中击败了83.22% 的用户
class Solution{
	public String shortestCompletingWord(String licensePlate,String[] words){
		int[] target = count(licensePlate);
		String ans = "";
		for(String word:words){
			if((word.length()< ans.length()||ans.length()==0) && dominates(count(word.toLowerCase()),target))
				ans = word;
			return ans;
		}
	}
	//比较两个数组里字母的值的大小
	public boolean dominates(int[] count1,int[] count2){
		for(int i = 0;i < 26;++i)
			if(count1[i] < count2[i])
				return false;
		return true;
	}
	//不分大小写，将单词字母统计存入ans
	public int[] count(String word){
		int[] ans = new int[26];
		for(char letter:word.toCharArray()){
			int index = Character.toLowerCase(letter)-'a';
			if(0 <=index && index < 26)
				ans[index]++;
		}
		return ans;
	}
}

【第十八题】设计哈希集合

在这里插入图片描述

分析：为了实现HashSet数据结构，有两个关键的问题，即哈希函数和冲突处理。

class MyHashSet{
	private Bucket[] bucketArray;
	private int keyRange;
public MyHashSet(){
	this.keyRange = 769;
	this.bucketArray = new Bucket[this.keyRange];
	for(int i = 0;i < this.keyRange;++i)
		this.bucketArray[i] = new Bucket();
}
protected int _hash(int key){
	return (key % this.keyRange);
}
public void add(int key){
	int bucketIndex = this._hash(key);
	
}

}
是菜鸟不是咸鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
出现奇数次的数字_查找出现奇数次的数字
cumudi0723的博客
06-30 921
出现奇数次的数字Problem statement 问题陈述 Given an array of positive numbers where all the numbers occur even number of times except only one number which occurs an odd number of times. We need to find the spe...
根据传入的sql查询结果返回HashMap<String,String>
m0_37989702的博客
07-13 2671
/**      * 根据所传入的sql查询，以Hashtable数组返回结果集.      * 取值形式 ：Hashtable[i]..get(字段名)，字段名须小写。      * @param sql sql查询语句      * @return Hashtable[] Hashtable数组           */     public HashMap[] getQuery(
C语言知识串讲（CH8）
亚洲彳亍女的博客
09-10 183
1）
第十七周 12.21---12.27
weixin_30315905的博客
12-25 83
12.21 --- 12.24 什么都没干 转载于:https://www.cnblogs.com/wuyuewoniu/p/5076690.html
2018.06.13学习笔记】【linux高级知识 12.21-12.24】
weixin_33894640的博客
06-14 85
2019独角兽企业重金招聘Python工程师标准>>> ...
读书笔记 --- 数据结构与算法分析C语言描述 --- 12.21 --- Chapter4 树 page65 - 69
CodeChicken的博客
12-21 230
4.0 引言 为解决链表的线性访问时间过慢这个问题，介绍一种大部分操作时间平均为O(log N)的数据结构 — 树 第二种修改，对于长的指令序列每种操作的运行时间基本上是O(log N) — 二叉查找树(Binary Search Tree) 树在cs中是非常有用的抽象概念，本章我们将学习： 树在操作系统中的文件系统的应用 树如何能够用来计算算术表达式的值(常考) 树支持O(log N)进行...
Linux 运维 11月30日 笔记 12.21-12.24
11-30 82
目录 一、 php-fpm的pool 二、 php-fpm慢执行日志 三、 open_basedir 四、 php-fpm进程管理 php-fpm的pool vim /usr/local/php/etc/php-fpm.conf 添加新的pool /usr/local...
12.21 - 每日一题 - 408
yanlei233的博客
12-21 772
每日一句：信心源于实力，实力源于不断的努力。 数据结构 1.与克鲁斯卡尔（Kruskal）相比，普里姆（Prim）算法更适于求哪种网的最小生成树 。（电子科技大学 2015年） A．边稠密的网 B．边稀疏的网 C．顶点稠密的网 D．以上都不是 答案：A 解析：克鲁斯卡尔算法每次添加新的边时都需要对剩下的边进行排序，所以对于边稠密的网，普利姆算法更适合。 拓展： 对比普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法 克鲁斯卡尔(Kruskal)算法主要针对边来展开，边数较少时效率非常
12.21-12.27
AB__C的博客
12-28 223
12月21日 746.使用最小花费爬楼梯 //动态规划 class Solution { public int minCostClimbingStairs(int[] cost) { if(cost.length == 2) { return cost[0] > cost[1] ? cost[1] : cost[0]; } for(int i = 2; i < cost.length; i ++) {
2010-12.21-2.rar_12.21_2407_交流异步_异步电机控制
07-15
三相交流异步电动机矢量控制程序. 此程序适用dsp 2407 控制三相一步电机，控制逆变电路，或者是开关电路
node-mongodb-todo:使用mongodb的Angular Node.js 12.21-Todo
04-14
Node Todo App A Node app built with MongoDB and Angular. For demonstration purposes and a tutorial. Node provides the RESTful API. Angular provides the frontend and accesses the API....
21-步进电机暂停功能_12.21_21-步进电机暂停功能_pcb_
09-29
......1-步进程序......2-电路原理图......3-视频讲解......4-相关软件下载和教程......5-仿真......6-实物图......7-制作详解......8-元件清单......9-任务书......10-开题报告......11-开发资料......12-pcb图
node-v12.21.0-win-x64.zip
04-24
它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如...
node-v12.21.0-darwin-x64.tar.xz
最新发布
05-01
它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如...
【Leecode笔记之C语言】第三周（9.21-9.27）
历乱的日记簿
09-22 479
【Day7】 第一题：宝石与石头 分析：直接在S里搜索和J相同的字符，双层for循环可实现。 问题在于：如何判断两个字符是否相等？ 第一个思路：在J中存在；（strchr函数，返回在J中的位置） 第二个思路：两字符相等。（strcmp函数，比较两个字符） int numJewelsInStones(char * J, char * S){ int num = 0; //int len = S.length(); for(int i = 0;S[i]!='\0';i++){
【牛客+力扣】高频题随机刷（5.3-5.9）
历乱的日记簿
05-10 331
1、二叉搜索树的第k个结点 输出第k小的结点 分析： 1、中序遍历二叉搜索树是节点值的升序排列 2、利用ArrayList的随机存取 //中序遍历 public class Solution { ArrayList<TreeNode> res = new ArrayList<>(); TreeNode KthNode(TreeNode pRoot, int k) { if(pRoot == null || k == 0){return null;}
【Leecode笔记之java】第十四周（12.7-12.13）字符串专题
历乱的日记簿
12-14 317
【第一题】验证回文字符串II 分析：双指针，i从开头遍历，j从末尾遍历，一个一个比较，碰到不相同的字符跳过，继续往前，碰到第二个不相同的字符，返回false。 这里问题就在于，当字符不相等的时候，是哪个指针往前走？ 分为两种情况： 1.i向前走，判断是否为回文； 2.j向前走，判断是否为回文。 这里可以设计成一个递归判断。 //执行用时：9 ms, 在所有 Java 提交中击败了56.24% 的用户 //内存消耗：38.8 MB, 在所有 Java 提交中击败了94.35% 的用户 //Q:为啥是(i,j
【Leecode笔记】第十八周下（1.5-1.8）位运算专题
历乱的日记簿
01-08 307
【第一题】丢失的数字 分析： 1.位运算异或。 2.求和。由1到n项的数列和-目前的sum 3.哈希表/桶 //1.位运算异或。 //执行用时：0 ms, 在所有 Java 提交中击败了100.00% 的用户 //内存消耗：38.9 MB, 在所有 Java 提交中击败了63.68% 的用户 class Solution{ public int missingNumber(int[] nums){ int res = nums.length; for(int i =
Directory is not readable: D:\tools\Hadoop\hadoop-2.7.7\data\dfs\datanode\current\BP-490180523-172.16.12.21-1692258474572
08-29
从引用中可以看出，报错信息中提到了JAVA_HOME未设置或找不到的问题。从引用中可以看到，在slave2节点上执行了命令"echo $JAVA_HOME"，结果为空。再从引用中可以看出，在hadoop-daemons.sh脚本中，会调用hadoop-config.sh脚本来设置环境变量，其中包括JAVA_HOME。因此，可以推测在配置文件中没有正确设置JAVA_HOME的路径，导致启动DataNode时出现错误。 至于您提到的"Directory is not readable: D:\tools\Hadoop\hadoop-2.7.7\data\dfs\datanode\current\BP-490180523-172.16.12.21-1692258474572"的问题，这是一个目录不可读的错误。根据错误信息，可能是由于路径中的某个目录没有正确的权限或者文件损坏导致的。您可以检查该路径下的相关目录和文件的权限是否正确，并确保文件没有损坏。 综上所述，解决这两个问题的步骤如下: 1. 在配置文件中正确设置JAVA_HOME的路径，确保该路径存在且正确。 2. 检查"D:\tools\Hadoop\hadoop-2.7.7\data\dfs\datanode\current\BP-490180523-172.16.12.21-1692258474572"路径下的目录和文件的权限，并确保文件没有损坏。 请注意，以上是基于提供的引用内容的推测，具体解决方法可能会因具体环境而有所不同。建议您按照以上步骤来解决问题，并在遇到其他问题时及时查找相关资料或咨询专业人士。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [Hadoop 启动 HDFS DataNode 时报错Error: JAVA_HOME is not set and could not be found.](https://blog.csdn.net/wangbaomi/article/details/108287757)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值