代码随想录算法训练营第六天|LeetCode242.有效的字母异位词|LeetCode349.两个数组的交集|LeetCode202.快乐数|LeetCode1.两数之和

LeetCode242.有效的字母异位词

        基本思路：使用一个hash表（table），把第一个字符串的每个字符当作key，当前字符出现的次数作为value传入到table中，然后再遍历第二个字符串，也向table里面push值，但是push的value是当前的值 - 1。每次遍历的时候，都判断当前的字符的value是否为负数，如果是负数了，说明这个字符在第二个字符串中多出现了，就返回false，反之继续下一轮循环。如果两个字符串的长度不想等也可以直接返回false。

Java代码如下：

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

LeetCode349.两个数组的交集

        基本思路：使用两个HashSet（set,resSet），一个集合存放的对象是唯一的，也就是不会出现重复的对象，先遍历第一个数组，将里面的所有数放入到set中，再遍历第二个数组，同时判断set中是否存在相同的数，如果有，放入到resSet中，反之继续循环。循环结束之后，将resSet转变为数组返回即可。

Java代码如下：

public int[] intersection(int[] nums1, int[] nums2) {
    	if(nums1.length == 0 || nums2.length == 0) 
    	{
    		return new int[0];
    	}
    	Set set = new HashSet<>();
    	Set resSet = new HashSet<>();
    	
    	for(int i = 0; i < nums1.length; i++) 
    	{
    		set.add(nums1[i]);
    	}
    	
    	for(int i = 0; i < nums2.length; i++) 
    	{
    		if(set.contains(nums2[i])) 
    		{
    			resSet.add(nums2[i]);
    		}
    	}
    	
    	//集合转换为数组
    	return resSet.stream().mapToInt(x -> x).toArray();
    }

 

 LeetCode202.快乐数

方法1.使用集合

        基本思路：写一个while循环，循环条件为 当前的值不等于1 并且 集合里面没有这个值 ，当前值不等于1是说明还没到最后一位，集合中没有这个值说明还没有出现循环，如果有的话，说明出现了循环，且如果当前值不等于1的话就返回false。

Java代码如下：

public boolean isHappy(int n) {
        Set set = new HashSet<>();
    	while(n != 1 && !set.contains(n)) 
    	{
    		set.add(n);
    		n = getNext(n);
    	}
    	
    	return n == 1;
    }

    public int getNext(int n) 
    {
    	int total = 0;
    	while(n > 0) 
    	{
    		int d = n % 10;
    		n = n / 10;
    		total += d * d;
    	}
    	
    	return total;
    }

 方法2.快慢指针

        基本思路：将结果序列看成一个链表，快指针一次走两步，慢指针一次走一步，如果没有循环，快指针肯定比慢指针先到达1的位置，如果有循环，那么快指针肯定会和慢指针在循环内相遇，因为快指针比慢指针多走了n圈，然后遇到了慢指针。两者相遇且值不等于1，返回false。

Java代码如下：

public boolean isHappy(int n) {
        int slow = n;
    	int fast = getNext(n);
    	while(fast != 1 && slow != fast) 
    	{
    		slow = getNext(slow); 
    		fast = getNext(getNext(fast));
    	}
    	return fast == 1;
    }

    public int getNext(int n) 
    {
    	int total = 0;
    	while(n > 0) 
    	{
    		int d = n % 10;
    		n = n / 10;
    		total += d * d;
    	}
    	
    	return total;
    }

LeetCode1.两数之和

        基本思路：使用HashMap，key存数组当前的值，value存储当前值的下标。遍历当前数组，判断target - nums[i] 是否存在于map中，如果存在，那么直接返回nums[i]以及target - nums[i]两个数的value，如果没有，就把当前的nums[i]和 i put到map中。循环结束，没有返回的话，就说明没有找到，返回空。

Java代码如下：

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