rename for java

Author: xiao2shiqi

src/main/java/IQ0201.java

@@ -0,0 +1,57 @@
+import java.util.HashSet;
+
+/**
+ * 面试题：02.01 移除重复节点
+ * Link：https://leetcode-cn.com/problems/remove-duplicate-node-lcci/
+ * 思路：哈希排重复
+ */
+public class IQ0201 {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) {
+            val = x;
+            next = null;
+        }
+
+        @Override
+        public String toString() {
+            return "ListNode{" +
+                    "val=" + val +
+                    ", next=" + next +
+                    '}';
+        }
+    }
+
+    public static ListNode removeDuplicateNodes(ListNode head) {
+        if (head == null) {
+            return null;
+        }
+        HashSet<Integer> hashSet = new HashSet<>();
+        hashSet.add(head.val);
+        ListNode moveNode = head;
+        while (moveNode.next != null) {
+            ListNode cur = moveNode.next;
+            if (hashSet.add(cur.val)) {
+                moveNode = moveNode.next;
+            } else {
+                moveNode.next = moveNode.next.next;
+            }
+        }
+        moveNode.next = null;
+        return head;
+    }
+
+    public static void main(String[] args) {
+        ListNode n1 = new ListNode(1);
+        ListNode n2 = new ListNode(2);
+        ListNode n3 = new ListNode(3);
+        ListNode n4 = new ListNode(2);
+        ListNode n5 = new ListNode(1);
+        n1.next = n2; n2.next = n3; n3.next = n4; n4.next = n5;
+
+        ListNode listNode = removeDuplicateNodes(n1);
+        System.out.println(listNode);
+    }
+}

src/main/java/IQ1001.java

@@ -0,0 +1,33 @@
+import java.util.Arrays;
+
+/**
+ * LC#IQ10.01：合并排序数组
+ * Link: https://leetcode-cn.com/problems/sorted-merge-lcci/
+ * 思路1：合并后排序 （效率低）
+ * 思路2：使用 k 从尾部开始往头插入元素（最优）
+ */
+public class IQ1001 {
+
+    public static void merge(int[] A, int m, int[] B, int n) {
+        int k = m + n - 1;
+        int i = m - 1;
+        int j = n - 1;
+        while (i >= 0 && j >= 0) {
+            if (A[i] < B[j]) {
+                A[k--] = B[j--];
+            } else {
+                A[k--] = A[i--];
+            }
+        }
+        while (j >= 0) {  A[k--] = B[j--]; }
+    }
+
+    public static void main(String[] args) {
+//        int[] nums1 = {1,2,3,0,0,0};
+//        int[] nums2 = {2,5,6};
+        int[] nums1 = {0};
+        int[] nums2 = {1};
+        merge(nums1, 0, nums2, 1);
+        System.out.println(Arrays.toString(nums1));
+    }
+}

src/main/java/PO18.java

@@ -0,0 +1,54 @@
+/**
+ * 剑指 Offer 18：删除链表的节点
+ * Link：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/
+ * 这道题跟 LC#237 极度相似，但是相对复杂很多，这是这里 head 参数是头节点， LC#237 传入参数为当前节点
+ * 思路：首选判断头指针为当前节点的情况，如果是头指针，处理起来就很方便
+ * 接下来通过遍历链表，找到目标节点的上一个节点，既 currentPrevNode 引用
+ * 处理 currentPrevNode 引用会出现两种情况：
+ * 1 存在 next.next 节点，需要将 next 节点的更新为 next.next 节点，完成删除操作
+ * 2 目标节点为最末尾的节点，要删除节点，为末尾节点，直接将当前引用的 next 引用删除即可 currentPrevNode.next = null
+ */
+public class PO18 {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) {
+            val = x;
+            next = null;
+        }
+    }
+
+    public static ListNode deleteNode(ListNode head, int val) {
+        if (head.val == val) {
+            return head.next;
+        }
+        ListNode currentPrevNode = null;
+        ListNode prev = head;
+        while (prev.next != null) {
+            if (prev.next.val == val) {
+                currentPrevNode = prev;
+                break;
+            }
+            prev = prev.next;
+        }
+        ListNode nextNode = currentPrevNode.next;
+        if (nextNode.next == null) {
+            currentPrevNode.next = null;
+        } else {
+            nextNode.val = nextNode.next.val;
+            nextNode.next = nextNode.next.next;
+        }
+        return head;
+    }
+
+    public static void main(String[] args) {
+        ListNode n1 = new ListNode(1);
+        ListNode n2 = new ListNode(2);
+        ListNode n3 = new ListNode(3);
+        n1.next = n2; n2.next = n3;
+
+        ListNode listNode = PO18.deleteNode(n1, 2);
+        System.out.println(listNode);
+    }
+}

src/main/java/PO22.java

@@ -0,0 +1,51 @@
+/**
+ * 剑指 Offer 22. 链表中倒数第k个节点
+ * Link：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/
+ * 思路1（简单）：先计算链表长度，算出 length - k 得出起始位置，直接返回 length - k 位置即可
+ * 思路2：使用 former 指针首先向前走 k 步，然后同时移动 former, latter 指针，当 former 为 null 时返回 latter 指针即可
+ */
+public class PO22 {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) {
+            val = x;
+            next = null;
+        }
+
+        @Override
+        public String toString() {
+            return "ListNode{" +
+                    "val=" + val +
+                    ", next=" + next +
+                    '}';
+        }
+    }
+
+    public static ListNode getKthFromEnd(ListNode head, int k) {
+        ListNode former = head;
+        ListNode latter = head;
+        for(int i = 0; i < k; i++) {
+            former = former.next;
+        }
+        while(former != null) {
+            former = former.next;
+            latter = latter.next;
+        }
+        return latter;
+    }
+
+    public static void main(String[] args) {
+        ListNode n1 = new ListNode(1);
+        ListNode n2 = new ListNode(2);
+        ListNode n3 = new ListNode(3);
+        ListNode n4 = new ListNode(4);
+        ListNode n5 = new ListNode(5);
+        n1.next = n2; n2.next = n3; n3.next = n4; n4.next = n5;
+
+        ListNode listNode = getKthFromEnd(n1, 2);
+        System.out.println(listNode);
+    }
+
+}

src/main/java/PO3.java

@@ -0,0 +1,25 @@
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * LC#OF03: 数组中重复的数字
+ * Link：https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/
+ * 思路：哈希排重
+ */
+public class PO3 {
+
+    public static int findRepeatNumber(int[] nums) {
+        Set<Integer> hashSet = new HashSet<>(nums.length);
+        for (int num : nums) {
+            if (hashSet.contains(num)) return num;
+            hashSet.add(num);
+        }
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {2, 3, 1, 0, 2, 5, 3};
+        int res = findRepeatNumber(nums);
+        System.out.println(res);
+    }
+}

src/main/java/PO52.java

@@ -0,0 +1,28 @@
+/**
+ * 剑指 Offer 52. 两个链表的第一个公共节点
+ * Link：https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/
+ * 思路1 相交链表：
+ */
+public class PO52 {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) {
+            val = x;
+            next = null;
+        }
+    }
+
+    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        ListNode pA = headA;
+        ListNode pB = headB;
+
+        while (pA != pB) {
+            pA = pA == null ? headB : pA.next;
+            pB = pB == null ? headA : pB.next;
+        }
+        return pA;
+    }
+
+}

src/main/java/PO6.java

@@ -0,0 +1,45 @@
+import java.util.Arrays;
+
+/**
+ * 剑指 Offer 06：从尾到头打印链表
+ * Link：https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/
+ * 思路（最优解）：1次遍历统计链表长度，倒序遍历将链表元素插入数组
+ */
+public class PO6 {
+
+    static class ListNode {
+        int val;
+        ListNode next;
+        ListNode(int x) {
+            val = x;
+            next = null;
+        }
+    }
+
+    public static int[] reversePrint(ListNode head) {
+        int count = 0;
+        ListNode prev = head;
+        while (prev != null) {
+            count++;
+            prev = prev.next;
+        }
+
+        int[] result = new int[count];
+        while (count != 0) {
+            result[count - 1] = head.val;
+            head = head.next;
+            count--;
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        ListNode n1 = new ListNode(1);
+        ListNode n2 = new ListNode(3);
+        ListNode n3 = new ListNode(2);
+
+        n1.next = n2; n2.next = n3;
+        int[] ints = PO6.reversePrint(n1);
+        System.out.println(Arrays.toString(ints));
+    }
+}

src/main/java/S1.java

@@ -0,0 +1,32 @@
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * LC#1：Two Sum 两数之和
+ * https://leetcode-cn.com/problems/two-sum/
+ * 思路1：2次哈希求解：将数组放入散列表，遍历散列表，通过target-key得出匹配数组，并且判断非自身元素，返回数组，时间复杂度 O（n）
+ * 思路2[runtime beats（最优解）]：1次哈希求解：在遍历 num 数组，如果哈希表不包含 target - num[i] ，则将 num[i], i 放入哈希表，如果包含则直接返回 [hash[num[i], i]] 下标
+ */
+public class S1 {
+
+    public static int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> hashMap = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            // 如果包含目标值
+            if(hashMap.containsKey(target - nums[i])) {
+                return new int[]{hashMap.get(target - nums[i]), i};
+            }
+            hashMap.put(nums[i], i);
+        }
+        return null;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {2, 7, 11, 15};
+        int target = 9;
+        int[] result = S1.twoSum(nums, target);
+        System.out.println(Arrays.toString(result));
+
+    }
+}

src/main/java/S100.java

@@ -0,0 +1,38 @@
+/**
+ * #100. Same Tree
+ * https://leetcode-cn.com/problems/same-tree/
+ */
+public class S100 {
+
+    public static boolean isSameTree(TreeNode p, TreeNode q) {
+        if(p == null && q == null) {
+            return true;
+        }
+
+        if(p != null && q != null && p.val == q.val) {
+            //递归遍历左子树和右子树
+            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+        } else {
+            return false;
+        }
+    }
+
+    public static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        public TreeNode(int val) {
+            this.val = val;
+        }
+    }
+
+    public static void main(String[] args) {
+        TreeNode n1 = new TreeNode(1);
+        n1.left = new TreeNode(2);
+        TreeNode n2 = new TreeNode(1);
+        n2.left = null;
+        n2.right = new TreeNode(2);
+        System.out.println("isTrue > " + isSameTree(n1, n2));
+
+    }
+}