LeetCodeday05

面试题 02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：

public class Leetcode0207 {
    public static void main(String[] args) {
        // 构造相交链表
        ListNode commonNode = new ListNode(4, new ListNode(5, new ListNode(6)));

        ListNode headA = new ListNode();
        ListNode aNode1 = new ListNode(1);
        ListNode aNode2 = new ListNode(2);
        ListNode aNode3 = new ListNode(3);
        headA.next = aNode1;
        aNode1.next = aNode2;
        aNode2.next = aNode3;
        aNode3.next = commonNode;

        ListNode headB = new ListNode();
        ListNode bNode1 = new ListNode(-1);
        ListNode bNode2 = new ListNode(-2);
        ListNode bNode3 = new ListNode(-3);
        headB.next = bNode1;
        bNode1.next = bNode2;
        bNode2.next = bNode3;
        bNode3.next = commonNode;

        ListNode intersectionNode = getIntersectionNode(headA, headB);
        System.out.println(intersectionNode);


    }

    public static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 获取A链表长度
        int lengthA = getLength(headA);
        // 获取B链表长度
        int lengthB = getLength(headB);
        //  获取链表长度之差
        int gap = Math.abs(lengthA - lengthB);
        // A 链表长
        if (lengthA >= lengthB) {
           return getCommonNode(headA,headB,gap);
        } else {
            return getCommonNode(headB,headA,gap);
        }

    }

    /**
     * 获取链表长度
     * @param head head
     * @return length
     */
    public static int getLength(ListNode head) {
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;
        ListNode cur = dummyHead;
        int length = 0;
        while (cur.next != null) {
            length++;
            cur = cur.next;
        }
        return length;
    }

    /**
     * 让长链表 移动 length 步
     * @param head 长链表
     * @param length 移动长度
     * @return 移动后链表
     */
    public static ListNode moveNode(ListNode head, int length) {
        ListNode cur = head;
        while (length-- > 0) {
            cur = cur.next;
        }
        return cur;
    }

    public static ListNode getCommonNode(ListNode longNode, ListNode shortNode, int gap) {
        // 让长链表 先走 gap 步
        longNode = moveNode(longNode, gap);
        // 两个链表开始遍历
        while (shortNode != null) {
            // 两个链表节点相同 是相交节点 返回节点
            if (shortNode.equals(longNode)) {
                return shortNode;
            }
            shortNode = shortNode.next;
            longNode = longNode.next;
        }
        // 遍历完都没找到 返回null
        return null;
    }
}

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false

public class Leetcode242 {

    public static void main(String[] args) {

        String s = "ab";
        String t = "abb";
        boolean anagram = isAnagram(s, t);
        System.out.println(anagram);
    }

    public static boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        //数组用作hash映射
        int[] records = new int[26];
        // 第一个数组 向records中加入元素
        for (int i = 0; i < s.length(); i++) {
            records[s.charAt(i) - 'a']++;
        }
        // 第二个数组向 records中减去元素
        for (int i = 0; i < t.length(); i++) {
            records[t.charAt(i) - 'a']--;
        }
        // 看records中元素的值是否都为 0
        for (int record : records) {
            // 不为零说明出现次数不一样
            if (record != 0) {
                return false;
            }
        }
        return true;
    }
}

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

public class Leetcode349 {
    public static void main(String[] args) {
        int[] nums1 = {12, 34, 4, 4, 5};
        int[] nums2 = {12, 12, 4};
        int[] intersection = intersection(nums1, nums2);
        Arrays.stream(intersection).forEach(s -> System.out.print(s + " "));
    }

    public static int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }

        HashSet<Integer> resultSet = new HashSet<>();
        HashSet<Integer> set = new HashSet<>();
        // nums1 放入set集合
        for (int k : nums1) {
            set.add(k);
        }
        // 遍历 nums2
        for (int k : nums2) {
            // 如果nums1的set中包含 就放到resultSet中
            if (set.contains(k)) {
                resultSet.add(k);
            }
        }
        // set 转为 int []
        return resultSet.stream().mapToInt(x -> x).toArray();

    }
}

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

public class Leetcode202 {
    public static void main(String[] args) {

        boolean happy = isHappy(2);
        System.out.println(happy);
    }

    public static boolean isHappy(int n) {
        // 题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现
        // 当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
        HashSet<Integer> set = new HashSet<>();
        while (n != 1 && !set.contains(n)) {
            set.add(n);
            n = getNum(n);
        }
        return n == 1;
    }

    private static int getNum(int n) {
        int res = 0;
        while (n > 0) {
            // 获取最低位
            int temp = n % 10;
            res += temp * temp;
            n = n / 10;
        }
        return res;
    }
}

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] ==9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

public class Leetcode1 {
    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        int target = 9;
        int[] ints = twoSum(nums, target);
        Arrays.stream(ints).forEach(s -> System.out.print(s + " "));
    }

    public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            // 获取差值
            int diff = target - nums[i];
            // 判断map中有该 差值吗
            if (map.containsKey(diff)) {
                //有就返回
                return new int[]{i, map.get(diff)};
            }
            //map key存value value为数组下标;
            map.put(nums[i], i);
        }
        return new int[]{};
    }
}