[Hamill] 코드 리뷰 요청

hamill/src/main/java/com/codesquad/datastructurestudy/basic/BinarySearch.java

@@ -0,0 +1,31 @@
+package com.codesquad.datastructurestudy.basic;
+
+public class BinarySearch {
+
+  private static int binarySearch(int[] numbers, int number, int first, int last) {
+    while (first <= last) {
+      int mid = (first + last) / 2;
+
+      if (numbers[mid] == number) {
+        return mid;
+      } else if (numbers[mid] < number) {
+        first = mid + 1;
+      } else {
+        last = mid - 1;
+      }
+    }
+    return -1;
+  }
+
+  public static void main(String[] args) {
+    int[] numbers = {1,2,3,4,5,6,7,8,9};
+    int number = 2;
+    int index = binarySearch(numbers, number, 0, numbers.length - 1);
+
+    if (index == -1) {
+      System.out.println("못찾았다");
+    } else {
+      System.out.println(index + "번째 인덱스에서 찾았다");
+    }
+  }
+}

hamill/src/main/java/com/codesquad/datastructurestudy/basic/BinarySearchOperationCount.java

@@ -0,0 +1,44 @@
+package com.codesquad.datastructurestudy.basic;
+
+import java.util.Arrays;
+
+public class BinarySearchOperationCount {
+
+  private static int binarySearch(int[] numbers, int number, int first, int last) {
+    int mid;
+    int opCount = 0;
+
+    while (first <= last) {
+      mid = (first + last) / 2;
+
+      if (numbers[mid] == number) {
+        return mid;
+      } else if (numbers[mid] < number) {
+        first = mid + 1;
+      } else {
+        last = mid - 1;
+      }
+      opCount++;
+    }
+    return opCount;
+  }
+
+  public static void main(String[] args) {
+    int[] arr1 = new int[500];
+    int[] arr2 = new int[5000];
+    int[] arr3 = new int[50000];
+    int number = 5000;
+
+    Arrays.fill(arr1, 0);
+    Arrays.fill(arr2, 0);
+    Arrays.fill(arr3, 0);
+
+    int opCount1 = binarySearch(arr1, number, 0, arr1.length - 1);
+    int opCount2 = binarySearch(arr2, number, 0, arr2.length - 1);
+    int opCount3 = binarySearch(arr3, number, 0, arr3.length - 1);
+
+    System.out.println("비교연산횟수 : " + opCount1);
+    System.out.println("비교연산횟수 : " + opCount2);
+    System.out.println("비교연산횟수 : " + opCount3);
+  }
+}

hamill/src/main/java/com/codesquad/datastructurestudy/basic/LinearSearch.java

@@ -0,0 +1,26 @@
+package com.codesquad.datastructurestudy.basic;
+
+public class LinearSearch {
+
+  private static int linearSearch(int[] numbers, int number) {
+    int i;
+    for (i = 0; i < numbers.length; i++) {
+      if (numbers[i] == number) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  public static void main(String[] args) {
+    int[] arr = {1,2,3,4,5};
+    int number = 2;
+    int index = linearSearch(arr, number);
+
+    if (index == -1) {
+      System.out.println("못찾았다");
+    } else {
+      System.out.println((index+1) + "번째 에서 찾았다");
+    }
+  }
+}

hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/ArrayList.java

@@ -0,0 +1,85 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class ArrayList implements List<Integer> {
+
+  private int[] numbers;
+  private int numOfData;
+
+  public ArrayList() {
+    this.numbers = new int[100];
+    this.numOfData = 0;
+  }
+
+  public ArrayList(int[] numbers, int numOfData) {
+    this.numbers = numbers;
+    this.numOfData = numOfData;
+  }
+
+  public void add(int index, Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+//      throw new ArrayIndexOutOfBoundsException();
+    }
+    this.numbers[index] = element;
+    numOfData++;
+  }
+
+  public void add(Integer element) {
+    if (numOfData > this.numbers.length) {
+      System.out.println("배열이 가득 찼습니다");
+    }
+    this.numbers[numOfData] = element;
+    numOfData++;
+  }
+
+  public int count() {
+    return this.numOfData;
+  }
+
+  public Integer get(int index) {
+    return this.numbers[index];
+  }
+
+  public Integer remove(int index) {
+    Integer data = this.numbers[index];
+
+    for (int i = index; i < this.numOfData - 1; i++) {
+      this.numbers[i] = this.numbers[i+1];
+    }
+
+    this.numOfData--;
+    return data;
+  }
+
+  public int size() {
+    return this.numbers.length;
+  }
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList();
+
+    // 데이터 삽입
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+
+    // 저장된 데이터 출력
+    System.out.println("현재 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(2);
+    list.remove(3);
+
+    System.out.println("삭제 후 데이터의 수: " + list.count());
+
+    for (int i = 0; i < list.count(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    System.out.println("삭제 후 배열 크기: " + list.size());
+  }
+}

hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/List.java

@@ -0,0 +1,27 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public interface List<T> {
+
+  void add(T element);
+  void add(int index, T element);
+
+  int count();
+
+  T get(int index);
+
+  T remove(int index);
+
+  int size();
+
+//  int indexOf(T o);
+//  int lastIndexOf(T o);
+
+//  ListIterator listIterator();
+//  ListIterator listIterator(int index);
+
+//  T set(int index, T element);
+
+//  void sort(Comparator c);
+
+//  List subList(int fromIndex, int toIndex);
+}

hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/ListMain.java

@@ -0,0 +1,35 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class ListMain {
+
+  public static void main(String[] args) {
+    List<Integer> list = new ArrayList<>();
+    for (int i = 0; i < 9; i++) {
+      list.add(i,i+1);
+    }
+
+    int sum = 0;
+    for (int i = 0; i < list.size(); i++) {
+      sum += list.get(i);
+    }
+    System.out.println("리스트의 합계는 : " + sum);
+
+    List list1 = new ArrayList();
+
+    for (int i = 0; i < list.size(); i++) {
+      if (!(list.get(i) % 3 == 0 || list.get(i) % 2 == 0)) {
+        list1.add(list.get(i));
+      }
+    }
+
+    Iterator<Integer> iterator = list1.iterator();
+    while (iterator.hasNext()) {
+      System.out.println(iterator.next());
+    }
+  }
+}