9주차 스터디💨

09/beom/BinTree.java

@@ -0,0 +1,209 @@
+package algorithmStudyTree;
+
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BinTree<K, V> {
+    static class Node<K, V>{
+        private K key;
+        private V data;
+        private Node<K,V> left;
+        private Node<K,V> right;
+
+        public Node(K key, V data, Node<K, V> left, Node<K, V> right) {
+            this.key = key;
+            this.data = data;
+            this.left = left;
+            this.right = right;
+        }
+
+        public K getKey() {
+            return key;
+        }
+
+        public V getData() {
+            return data;
+        }
+
+        void print(){
+            System.out.println(data);
+        }
+    }
+
+    private Node<K,V> root;
+    private Comparator<? super K> comparator =null; //비교자
+
+    public BinTree() {
+        root = null;
+    }
+
+    public BinTree(Comparator<? super K> c) {
+        this();
+        this.comparator = c;
+    }
+
+    private int comp(K key1, K key2){
+        return (comparator == null) ? ((Comparable<K>) key1).compareTo(key2)
+                : comparator.compare(key1, key2);
+    }
+
+    public V search(K key){
+        Node<K,V> p = root;
+
+        while(true){
+            if(p==null)
+                return null;
+            int cond = comp(key, p.getKey());
+            if(cond == 0){
+                //System.out.println(p.getData());
+                return p.getData();
+            }
+            else if(cond <0)
+                p = p.left;
+            else
+                p=p.right;
+        }
+    }
+
+    private void addNode(Node<K,V> node, K key, V data){
+        int cond = comp(key, node.getKey());
+        if(cond ==0)
+            return;
+        else if(cond < 0){
+            if(node.left == null)
+                node.left = new Node<K, V>(key, data,null,null);
+            else
+                addNode(node.left, key,data);
+        } else{
+            if(node.right == null)
+                node.right = new Node<K, V>(key, data,null,null);
+            else
+                addNode(node.right, key,data);
+        }
+    }
+
+    //addNode는 private로 외부에서 사용x
+    public void add(K key, V data){
+        if(root == null)
+            root = new Node<K,V>(key,data,null,null);
+        else
+            addNode(root, key, data);
+    }
+
+    public boolean remove(K key){
+        Node<K,V> p = root;
+        Node<K,V> parent = null;
+        boolean isLeftChild = true;
+
+        while (true){
+            if(p==null)
+                return false;
+            int cond = comp(key,p.getKey());
+            if (cond == 0)
+                break;
+            else{
+                parent = p;
+                if(cond < 0){
+                    isLeftChild = true;
+                    p = p.left;
+                } else {
+                    isLeftChild = false;
+                    p = p.right;
+                }
+            }
+        }
+
+        if(p.left == null){
+            if(p == root)
+                root = p.right;
+            else if(isLeftChild)
+                parent.left = p.right;
+            else
+                parent.right = p.right;
+        } else if(p.right ==null){
+            if(p == root)
+                root = p.left;
+            else if(isLeftChild)
+                parent.left = p.left;
+            else
+                parent.right = p.left;
+        } else{
+            parent = p;
+            Node<K,V> left = p.left;
+            isLeftChild = true;
+            while(left.right != null){
+                parent = left;
+                left = left.right;
+                isLeftChild = false;
+            }
+            p.key = left.key;
+            p.data = left.data;
+            if(isLeftChild)
+                parent.left = left.left;
+            else
+                parent.right = left.left;
+        }
+        return true;
+    }
+
+    private void preOrder(Node node){
+        if(node != null){
+            System.out.print(node.data + " " );
+            if(node.left != null) preOrder(node.left);
+            if(node.right != null) preOrder(node.right);
+        }
+    }
+
+    public void printPreOrder(){
+        preOrder(root);
+    }
+
+    private void inOrder(Node node){
+        if(node != null){
+            if(node.left != null) inOrder(node.left);
+            System.out.print(node.data + " ");
+            if(node.right != null) inOrder(node.right);
+        }
+    }
+
+    public void printInOrder(){
+        inOrder(root);
+    }
+
+    private void postOrder(Node node){
+        if(node != null){
+            if(node.left != null) postOrder(node.left);
+            if(node.right != null) postOrder(node.right);
+            System.out.print(node.data + " ");
+        }
+    }
+
+    public void printPostOrder(){
+        postOrder(root);
+    }
+
+    private void levelOrder(Node a){
+        Queue<Node> queue= new LinkedList<>();
+        queue.offer(a);
+
+        while(!queue.isEmpty()){
+            Node node = queue.poll();
+            System.out.print(node.getData()+ " ");
+
+            if(node.left != null){
+                queue.offer(node.left);
+            }
+
+            if(node.right != null){
+                queue.offer(node.right);
+            }
+        }
+    }
+
+    public void printLevelOrder(){
+        levelOrder(root);
+    }
+
+
+}

09/beom/Leetcode.md

@@ -0,0 +1,182 @@
+# Tree
+## 목차
+- 99. Recover Binary Search Tree
+- 222. Count Complete Tree Nodes
+- 112. Path Sum
+
+
+## 99. Recover Binary Search Tree
+### 문제 요약
+BST의 순서가 잘못된 것을 복원하시오
+
+> 풀이</br>
+> 주어진 root를 중위순회 방식으로 하여 오름차순 또는 내림차순으로 정렬된 배열을 바꿔야할 것같다는 생각까지만 들었다. 하지만 그 이후로는 생각이 나지 않아 discuss의 도움을 받았다.
+
+### 시간 복잡도 공간복잡도
+| time | space |
+|------|-------|
+| O(n) | O(n)  |
+
+### 코드
+```java
+class Solution {
+    TreeNode prev = null;
+    TreeNode first = null;
+    TreeNode second = null;
+
+    public void recoverTree(TreeNode root) {
+        inOrder(root);
+        int temp = first.val;
+        first.val = second.val;
+        second.val = temp;
+    }
+
+    public void inOrder(TreeNode root){
+        if(root==null)return;
+        inOrder(root.left);
+
+        if(prev!=null&&root.val<prev.val){
+            if(first==null)first=prev;
+            second=root;
+        }
+        prev=root;
+        inOrder(root.right);
+
+    }
+}
+```
+
+
+## 222. Count Complete Tree Nodes
+### 문제 요약
+완전 이진 트리의 루트 노드가 입력으로 주어지면 트리의 노드 수를 반환해라
+
+### 시간 복잡도 공간복잡도
+| time | space |
+|------|-------|
+| O(log2 n) | O(n)  |
+
+
+
+### 코드
+```java
+class Solution {
+    int count = 0;
+
+    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;
+        }
+    }
+    public int countNodes(TreeNode root) {
+        if(root == null) return 0;
+
+        fixCount(root);
+        return count;
+    }
+
+    public void fixCount(TreeNode node){
+        count++;
+
+        if(node.left != null){
+            fixCount(node.left);
+        }
+
+        if(node.right != null){
+            fixCount(node.right);
+        }
+    }
+
+}
+```
+
+
+
+## 112. Path Sum
+### 문제 요약
+주어진 이진트리를 root부터 leaf 노드까지 탐색하여 targetSum과 일치하는 값이 있는지 찾아가는 문제입니다.
+
+### 시간 복잡도 공간복잡도
+| time | space |
+|------|-------|
+| O(log2 n) | O(n)  |
+
+### 코드
+```java
+class Solution {
+    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;
+        }
+    }
+
+    public boolean hasPathSum(TreeNode root, int targetSum) {
+        if(root == null){
+            return false;
+        }
+        if(root.left == null && root.right == null){
+            if(targetSum == root.val){
+                return true;
+            }else{
+               return false;
+            }
+        }
+
+        int requiredSum = targetSum - root.val;
+        return hasPathSum(root.left, requiredSum) || hasPathSum(root.right, requiredSum);
+    }
+}
+```
+
+
+## 705. Design HashSet
+### 문제 요약
+
+### 시간 복잡도 공간복잡도
+
+### 코드
+
+
+
+## 705. Design HashSet
+### 문제 요약
+
+### 시간 복잡도 공간복잡도
+
+### 코드
+
+
+
+
+## 705. Design HashSet
+### 문제 요약
+
+### 시간 복잡도 공간복잡도
+
+### 코드