LeeCode

#136[2022.3.11] 只出现一次的数字Ⅰ

异或运算的性质

class Solution {
    public int singleNumber(int[] nums) {
        //异或运算
        //异或运算满足结合率和交换律。
        int single = 0;
        for(int num : nums) {
            single ^= num;
        }
        return single;
    }
}

#137 只出现一次的数字Ⅱ

HashMap

class Solution {
    public int singleNumber(int[] nums) {
        Map<Ingeter, Integer> freq = new HashMap<Integer, Integer>();
        for(int num : nums) {
            freq.put(num, freq.getOrDefault(num, 0) + 1);
            //map.getOrDefault(Object key, V defaultvalue)
            //如果key存在则取key的值，否则取defaultvalue
        }
        int ans = 0;
        for(Map.Entry<Integer, Integer> entry: freq.entrySet()) {
            int num = entry.getKey(), occ = entry.getValue();
            if(num == 1) {
                ans =num;
                break;
            }
        }
        return ans;
    }
}

#141[2022.3.11] 判断链表是否有环

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null) {
            return false;
        }
        ListNode slow = head;
        ListNode fast = head;
        int pos = 0;
        while(slow.next != null && fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next;
            fast = fast.next;
            if(slow == fast) {
                return true;
            }
        }
        return false;
        
    }
}

# 142[2022.3.11] 环形链表Ⅱ：找到入环点

数学推理集大成题。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        if(slow == null) {
            return null;
        }
        while(fast != null) {
            slow = slow.next;
            if(fast.next != null) {
                fast = fast.next.next;
            } else {
                return null;
            }

            if(slow == fast) {
                ListNode ptr = head;
                while(ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }
        return null;
    }
}

#144[2022.3.11] 二叉树前序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;

    }
    public void preorder(TreeNode root, List a) {
        if(root == null) {
            return;
        }
        a.add(root.val);
        //ArrayList添加元素方法a.add()
        preorder(root.left, a);
        preorder(root.right, a);
    }
}

#217[20223.11] 数组是否存在重复元素

//可以用HashMap,但此时HashSet更适合，因为HashSet不允许存入重复元素。
class Solution {
    public boolean containsDuplicate(int[] nums) {
        //用HashMap
        // int n = nums.length;
        // Map<Integer,Integer> res = new HashMap<Integer, Integer>();
        // for(int i=0; i<n; i++) {
        //     if(res.containsKey(nums[i])) {
        //         return true;
        //     } else {
        //     res.put(nums[i], i);
        //     }
        // }
        // return false;
        
        //用HashSet
        Set<Integer> res = new HashSet<Integer>();
        for(int num : nums) {
            if(!res.add(num)) {
                return true;
            }
        } 
        return false;
    }
}

#219[2022.3.11] 存在重复元素Ⅱ（重复元素下标的距离在一定范围内）

用HashMap

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