add week2 algorithm solutions

Author: xeulbn

.gitignore

@@ -2,3 +2,4 @@
 .vscode/
 .DS_Store
 .env
+*.iml

3sum/xeulbn.java

@@ -0,0 +1,52 @@
+import java.util.*;
+
+//시간복잡도 : O(n^2), 공간복잡도 : O(nlogn)
+
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+
+        Arrays.sort(nums);
+        List<List<Integer>> answer = new ArrayList<>();
+
+        for(int i=0;i<nums.length-2;i++){
+            if (i>0 && nums[i] == nums[i-1]) {
+                continue;
+            }
+            int leftIndex = i+1;
+            int rightIndex = nums.length-1;
+
+            while(leftIndex<rightIndex){
+                int sum =nums[i]+nums[leftIndex]+nums[rightIndex];
+
+                if(sum==0){
+                    // 정답 추가
+                    List<Integer> tmpList = new ArrayList<>();
+                    tmpList.add(nums[i]);
+                    tmpList.add(nums[leftIndex]);
+                    tmpList.add(nums[rightIndex]);
+
+                    answer.add(tmpList);
+
+                    // left++, right--
+                    leftIndex+=1;
+                    rightIndex-=1;
+
+                    // 중복 제거
+                    while(leftIndex<rightIndex && nums[leftIndex]==nums[leftIndex-1]){
+                        leftIndex+=1;
+                    }
+                    while(leftIndex<rightIndex && nums[rightIndex]==nums[rightIndex+1]){
+                        rightIndex-=1;
+                    }
+
+                }else if(sum<0){
+                    leftIndex+=1;
+                }else{
+                    rightIndex-=1;
+                }
+            }
+        }
+
+        return answer;
+    }
+}

climbing-stairs/xeulbn.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+//시간복잡도 : O(n), 공간복잡도 : O(n)
+//이전 두 값만 필요하기에, 공간복잡도는 O(1)까지 최적화가 가능.
+
+class Solution {
+    public int climbStairs(int n) {
+        if(n<=2){
+            return n;
+        }
+
+        int[] dp =new int[n+1];
+        dp[1]=1;
+        dp[2]=2;
+
+        for(int i=3;i<n+1;i++){
+            dp[i]=dp[i-1]+dp[i-2];
+        }
+
+        return dp[n];
+
+    }
+}

product-of-array-except-self/xeulbn.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+//시간 복잡도 O(n), 공간 복잡도 O(1)
+
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int n = nums.length;
+        int[] answer = new int[n];
+
+        answer[0] = 1;
+        for (int i=1; i<n; i++) {
+            answer[i] = answer[i-1] * nums[i-1];
+        }
+
+        int suffix = 1;
+        for (int i = n-1; i >= 0; i--) {
+            answer[i] = answer[i] * suffix;
+            suffix *= nums[i];
+        }
+
+        return answer;
+    }
+}

valid-anagram/xeulbn.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+// 시간복잡도 : O(n), 공간복잡도 : O(n)
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+
+        if(s.length()!=t.length()){
+            return false;
+        }
+
+        Map<Character,Integer> characterMap = new HashMap<>();
+
+        for(int i=0;i<s.length();i++){
+            char c = s.charAt(i);
+            characterMap.put(c,characterMap.getOrDefault(c,0)+1);
+        }
+
+        for(int i=0;i<t.length();i++){
+            char c = t.charAt(i);
+
+            if(!characterMap.containsKey(c)){
+                return false;
+            }
+
+            characterMap.put(c, characterMap.get(c) - 1);
+            if(characterMap.get(c)<0){
+                return false;
+            }
+        }
+        return true;
+    }
+}

validate-binary-search-tree/xeulbn.java

@@ -0,0 +1,39 @@
+import java.util.*;
+
+
+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 boolean isValidBST(TreeNode root) {
+        return validate(root, Long.MIN_VALUE, Long.MAX_VALUE);
+    }
+
+    private boolean validate(TreeNode node, long min, long max) {
+        if (node == null) {
+            return true;
+        }
+
+        if (node.val <= min || node.val >= max) {
+            return false;
+        }
+
+        return validate(node.left, min, node.val) && validate(node.right, node.val, max);
+    }
+}