面试题 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[]{};
}
}
