add for two-sum

Author: houbb

src/main/java/com//houbb/leetcode/datastruct/array/T001_twoSum_V1_BF.java

@@ -0,0 +1,22 @@
+package com..houbb.leetcode.datastruct.array;
+
+public class T001_twoSum_V1_BF {
+
+
+public int[] twoSum(int[] nums, int target) {
+int[] res = new int[2];
+
+final int n = nums.length;
+for(int i = 0; i < n; i++) {
+for(int j = i+1; j < n; j++) {
+if(nums[i] + nums[j] == target) {
+res[0] = i;
+res[1] = j;
+}
+}
+}
+
+return res;
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T001_twoSum_V2_SortBinarySearch.java

@@ -0,0 +1,66 @@
+package com..houbb.leetcode.datastruct.array;
+
+import java.util.*;
+
+public class T001_twoSum_V2_SortBinarySearch {
+
+
+/**
+* @param nums
+* @param target
+* @return
+*/
+public int[] twoSum(int[] nums, int target) {
+int n = nums.length;
+
+// 存储值+下标 避免排序后找不到原始的索引
+List<int[]> indexList = new ArrayList<>();
+for(int i = 0; i < n; i++) {
+indexList.add(new int[]{nums[i], i});
+}
+Collections.sort(indexList, new Comparator<int[]>() {
+@Override
+public int compare(int[] o1, int[] o2) {
+return o1[0] - o2[0];
+}
+});
+
+// 遍历+二分 这里直接手写二分比较简单，因为直接查询数字可能会重复
+for(int i = 0; i < n-1; i++) {
+int t = target - indexList.get(i)[0];
+//从当前 i 的后面开始寻找
+int j = binarySearch(indexList, t, i+1);
+if(j > 0) {
+return new int[]{i, j};
+}
+}
+
+//NOT FOUND
+return new int[]{-1, -1};
+}
+
+private int binarySearch(List<int[]> indexList,
+final int target,
+final int startIx) {
+int left = startIx;
+int right = indexList.size()-1;
+while (left <= right) {
+int mid = left + (right-left) / 2;
+int val = indexList.get(mid)[0];
+if(val == target) {
+// 原始下标
+return indexList.get(mid)[1];
+}
+
+// update
+if(val < target) {
+left = mid+1;
+} else {
+right = mid-1;
+}
+}
+
+return -1;
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T001_twoSum_V2_SortBinarySearch_ERR.java

@@ -0,0 +1,38 @@
+package com..houbb.leetcode.datastruct.array;
+
+import java.util.Arrays;
+
+@Deprecated
+public class T001_twoSum_V2_SortBinarySearch_ERR {
+
+
+/**
+* 错误的代码
+* @param nums
+* @param target
+* @return
+*/
+public int[] twoSum(int[] nums, int target) {
+int[] res = new int[2];
+
+Arrays.sort(nums);
+
+// 遍历+二分
+int n = nums.length;
+for(int i = 0; i < n; i++) {
+// 找另一部分
+int t = target - nums[i];
+
+// 找到了自己怎么办？
+int j = Arrays.binarySearch(nums, t);
+if(j > 0) {
+res[0] = i;
+res[1] = j;
+return res;
+}
+}
+
+return res;
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T001_twoSum_V3_HashMap.java

@@ -0,0 +1,30 @@
+package com..houbb.leetcode.datastruct.array;
+
+import java.util.*;
+
+public class T001_twoSum_V3_HashMap {
+
+
+/**
+* @param nums
+* @param target
+* @return
+*/
+public int[] twoSum(int[] nums, int target) {
+int n = nums.length;
+
+HashMap<Integer, Integer> hashMap = new HashMap<>();
+for(int i = 0; i < n; i++) {
+int other = target - nums[i];
+if(hashMap.containsKey(other)) {
+int j = hashMap.get(other);
+return new int[]{i, j};
+}
+// 存储
+hashMap.put(nums[i], i);
+}
+
+return new int[]{-1, -1};
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T001_twoSum_V3_SortTwoPointer.java

@@ -0,0 +1,52 @@
+package com..houbb.leetcode.datastruct.array;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class T001_twoSum_V3_SortTwoPointer {
+
+
+/**
+* @param nums
+* @param target
+* @return
+*/
+public int[] twoSum(int[] nums, int target) {
+int n = nums.length;
+
+// 存储值+下标 避免排序后找不到原始的索引
+List<int[]> indexList = new ArrayList<>();
+for(int i = 0; i < n; i++) {
+indexList.add(new int[]{nums[i], i});
+}
+Collections.sort(indexList, new Comparator<int[]>() {
+@Override
+public int compare(int[] o1, int[] o2) {
+return o1[0] - o2[0];
+}
+});
+
+// 双指针
+int left = 0;
+int right = n-1;
+while (left < right) {
+int sum = indexList.get(left)[0] - indexList.get(right)[0];
+
+if(sum == target) {
+return new int[]{indexList.get(left)[1]+1, indexList.get(right)[1]+1};
+}
+if(sum < target) {
+left++;
+}
+if(sum > target) {
+right--;
+}
+}
+
+//NOT FOUND
+return new int[]{-1, -1};
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T167_twoSum_V1_BF.java

@@ -0,0 +1,21 @@
+package com..houbb.leetcode.datastruct.array;
+
+public class T167_twoSum_V1_BF {
+
+public int[] twoSum(int[] nums, int target) {
+int[] res = new int[2];
+
+final int n = nums.length;
+for(int i = 0; i < n; i++) {
+for(int j = i+1; j < n; j++) {
+if(nums[i] + nums[j] == target) {
+res[0] = i+1;
+res[1] = j+1;
+}
+}
+}
+
+return res;
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T167_twoSum_V2_SortBinarySearch.java

@@ -0,0 +1,41 @@
+package com..houbb.leetcode.datastruct.array;
+
+public class T167_twoSum_V2_SortBinarySearch {
+
+public int[] twoSum(int[] nums, int target) {
+final int n = nums.length;
+for(int i = 0; i < n; i++) {
+int other = target - nums[i];
+
+int j = binarySearch(nums, other, i+1);
+if(j >= 0) {
+return new int[]{i+1, j+1};
+}
+}
+
+return new int[]{-1, -1};
+}
+
+private int binarySearch(int[] nums,
+int target,
+int startIx) {
+int left = startIx;
+int right = nums.length-1;
+
+while (left <= right) {
+int mid = left + (right - left) / 2;
+int val = nums[mid];
+if(val == target) {
+return mid;
+}
+if(val > target) {
+right = mid-1;
+} else {
+left = mid+1;
+}
+}
+
+return -1;
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T167_twoSum_V3_HashMap.java

@@ -0,0 +1,22 @@
+package com..houbb.leetcode.datastruct.array;
+
+import java.util.HashMap;
+
+public class T167_twoSum_V3_HashMap {
+
+public int[] twoSum(int[] nums, int target) {
+int n = nums.length;
+HashMap<Integer, Integer> hashMap = new HashMap<>();
+for(int i = 0; i < n; i++) {
+int other = target - nums[i];
+if(hashMap.containsKey(other)) {
+int j = hashMap.get(other);
+return new int[]{j+1, i+1};
+}
+// 存储
+hashMap.put(nums[i], i);
+}
+return new int[]{-1, -1};
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T167_twoSum_V4_TwoPointer.java

@@ -0,0 +1,26 @@
+package com..houbb.leetcode.datastruct.array;
+
+public class T167_twoSum_V4_TwoPointer {
+
+public int[] twoSum(int[] nums, int target) {
+int n = nums.length;
+int left = 0;
+int right = n-1;
+
+while (left < right) {
+int sum = nums[left] + nums[right];
+if(sum == target) {
+return new int[]{left+1, right+1};
+}
+if(sum < target) {
+left++;
+}
+if(sum > target) {
+right--;
+}
+}
+
+return new int[]{-1, -1};
+}
+
+}

src/main/java/com//houbb/leetcode/datastruct/array/T653_twoSumIV_V1_PreOrderHashSet.java

@@ -0,0 +1,53 @@
+package com..houbb.leetcode.datastruct.array;
+
+import com..houbb.leetcode.component.TreeNode;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class T653_twoSumIV_V1_PreOrderHashSet {
+
+/**
+* 前序遍历
+*
+* 数据=》
+*
+* @param root
+* @param k
+* @return
+*/
+public boolean findTarget(TreeNode root, int k) {
+// 构建结果列表
+Set<Integer> numSet = new HashSet<>();
+
+int[] resFlag = new int[]{1};
+resFlag[0] = 0;
+preOrderTravel(numSet, root, k, resFlag);
+
+return resFlag[0] != 0;
+}
+
+private void preOrderTravel(Set<Integer> numSet,
+TreeNode root,
+int k,
+int[] resFlag) {
+if(root == null || resFlag[0] != 0) {
+return;
+}
+
+// 符合
+int value = root.val;
+if(numSet.contains(k - value)) {
+resFlag[0] = 1;
+return;
+}
+numSet.add(value);
+
+preOrderTravel(numSet, root.left, k, resFlag);
+
+preOrderTravel(numSet, root.right, k, resFlag);
+}
+
+
+}