diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 8a770ea..17eee86 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -4,9 +4,10 @@
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
+        <option name="delegatedBuild" value="true" />
+        <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$/hamill" />
-        <option name="gradleJvm" value="11" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$/hamill" />
diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml
new file mode 100644
index 0000000..e96534f
--- /dev/null
+++ b/.idea/uiDesigner.xml
@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Palette2">
+    <group name="Swing">
+      <item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
+      </item>
+      <item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
+      </item>
+      <item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.png" removable="false" auto-create-binding="false" can-attach-label="true">
+        <default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
+        <initial-values>
+          <property name="text" value="Button" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="RadioButton" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="CheckBox" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
+        <initial-values>
+          <property name="text" value="Label" />
+        </initial-values>
+      </item>
+      <item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
+          <preferred-size width="150" height="-1" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
+          <preferred-size width="150" height="50" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <preferred-size width="200" height="200" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
+          <preferred-size width="200" height="200" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.png" removable="false" auto-create-binding="true" can-attach-label="true">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
+      </item>
+      <item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
+      </item>
+      <item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
+      </item>
+      <item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
+          <preferred-size width="-1" height="20" />
+        </default-constraints>
+      </item>
+      <item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.png" removable="false" auto-create-binding="false" can-attach-label="false">
+        <default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
+      </item>
+      <item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
+        <default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
+      </item>
+    </group>
+  </component>
+</project>
\ No newline at end of file
diff --git a/hamill/.gradle/5.2.1/executionHistory/executionHistory.bin b/hamill/.gradle/5.2.1/executionHistory/executionHistory.bin
index 402ae20..476adf1 100644
Binary files a/hamill/.gradle/5.2.1/executionHistory/executionHistory.bin and b/hamill/.gradle/5.2.1/executionHistory/executionHistory.bin differ
diff --git a/hamill/.gradle/5.2.1/executionHistory/executionHistory.lock b/hamill/.gradle/5.2.1/executionHistory/executionHistory.lock
index 52e2290..a104750 100644
Binary files a/hamill/.gradle/5.2.1/executionHistory/executionHistory.lock and b/hamill/.gradle/5.2.1/executionHistory/executionHistory.lock differ
diff --git a/hamill/.gradle/5.2.1/fileHashes/fileHashes.bin b/hamill/.gradle/5.2.1/fileHashes/fileHashes.bin
index 82c0993..567434f 100644
Binary files a/hamill/.gradle/5.2.1/fileHashes/fileHashes.bin and b/hamill/.gradle/5.2.1/fileHashes/fileHashes.bin differ
diff --git a/hamill/.gradle/5.2.1/fileHashes/fileHashes.lock b/hamill/.gradle/5.2.1/fileHashes/fileHashes.lock
index 107fb9d..cdeabaa 100644
Binary files a/hamill/.gradle/5.2.1/fileHashes/fileHashes.lock and b/hamill/.gradle/5.2.1/fileHashes/fileHashes.lock differ
diff --git a/hamill/.gradle/buildOutputCleanup/buildOutputCleanup.lock b/hamill/.gradle/buildOutputCleanup/buildOutputCleanup.lock
index 18d6721..f66c10f 100644
Binary files a/hamill/.gradle/buildOutputCleanup/buildOutputCleanup.lock and b/hamill/.gradle/buildOutputCleanup/buildOutputCleanup.lock differ
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/basic/BinarySearch.java b/hamill/src/main/java/com/codesquad/datastructurestudy/basic/BinarySearch.java
new file mode 100644
index 0000000..1e96394
--- /dev/null
+++ b/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 + "번째 인덱스에서 찾았다");
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/basic/BinarySearchOperationCount.java b/hamill/src/main/java/com/codesquad/datastructurestudy/basic/BinarySearchOperationCount.java
new file mode 100644
index 0000000..b4fe27a
--- /dev/null
+++ b/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);
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/basic/LinearSearch.java b/hamill/src/main/java/com/codesquad/datastructurestudy/basic/LinearSearch.java
new file mode 100644
index 0000000..736acb7
--- /dev/null
+++ b/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) + "번째 에서 찾았다");
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/ArrayList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/ArrayList.java
new file mode 100644
index 0000000..6593115
--- /dev/null
+++ b/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());
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/List.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/List.java
new file mode 100644
index 0000000..aa404b2
--- /dev/null
+++ b/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);
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/ListMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/ListMain.java
new file mode 100644
index 0000000..ef1713e
--- /dev/null
+++ b/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());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/NameCard.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/NameCard.java
new file mode 100644
index 0000000..7eb2c97
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/NameCard.java
@@ -0,0 +1,50 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public class NameCard {
+
+  private String[] name;
+  private String[] phone;
+
+  // NameCard 구조체 변수의 동적 할당 및 초기화 후 주소 값 반환
+  public NameCard(String[] name, String[] phone) {
+    this.name = name;
+    this.phone = phone;
+  }
+
+  public NameCard() {
+    this.name = new String[30];
+    this.phone = new String[30];
+  }
+
+  // NameCard 구조체 변수의 정보 출력
+  public static void showNameCardInfo(NameCard nameCard) {
+    System.out.println("[이름] : " + nameCard.name);
+    System.out.println("[번호] : " + nameCard.phone);
+  }
+
+  // 이름이 같으면 true, 다르면 false 값 반환
+  public static boolean nameCompare(NameCard nameCard, String[] name) {
+    return nameCard.name.equals(name);
+  }
+
+  // 전화번호 정보를 변경
+  public static void changePhoneNum(NameCard nameCard, String[] phone) {
+    nameCard.phone = phone;
+  }
+
+  public static void main(String[] args) {
+    NameCard nameCard = new NameCard();
+    List<Integer> list = new ArrayList();
+
+    // 총 3명의 전화번호 정보를, 앞서 우리가 구현한 리스트에 저장한다.
+    nameCard.name[0] = "이진수";
+    nameCard.name[1] = "한지영";
+    nameCard.name[2] = "조수진";
+    nameCard.phone[0] = "010-1111-2222";
+    nameCard.phone[1] = "010-2222-5555";
+    nameCard.phone[2] = "010-3333-7777";
+
+  }
+
+
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/Wallet.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/Wallet.java
new file mode 100644
index 0000000..261cc29
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/arraylist/Wallet.java
@@ -0,0 +1,13 @@
+package com.codesquad.datastructurestudy.list.arraylist;
+
+public interface Wallet {
+
+  // 모든 멤버변수는 public static final. 생략 가능
+  int coin100Num = 0;
+  int bill5000Num = 0;
+
+  // 모든 메서드는 public abstract 이어야함. 생략 가능
+  int takeOutMoney(int coin100Num, int bill5000Num);
+  void putMoney(int coin100Num, int bill5000Num);
+
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/DoublyLinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/DoublyLinkedList.java
similarity index 98%
rename from hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/DoublyLinkedList.java
rename to hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/DoublyLinkedList.java
index f3fe87b..7f25f5c 100644
--- a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/DoublyLinkedList.java
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/DoublyLinkedList.java
@@ -1,4 +1,4 @@
-package com.codesquad.datastructurestudy.linkedlist;
+package com.codesquad.datastructurestudy.list.linkedlist;
 
 /**
  * This class implements a DoublyLinkedList. This is done using the classes
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/Link.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/Link.java
similarity index 95%
rename from hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/Link.java
rename to hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/Link.java
index 5b2069e..433f1ae 100644
--- a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/Link.java
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/Link.java
@@ -1,4 +1,4 @@
-package com.codesquad.datastructurestudy.linkedlist;
+package com.codesquad.datastructurestudy.list.linkedlist;
 
 public class Link {
     /**
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/LinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/LinkedList.java
similarity index 99%
rename from hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/LinkedList.java
rename to hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/LinkedList.java
index b979e92..56435cb 100644
--- a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/LinkedList.java
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/LinkedList.java
@@ -1,4 +1,4 @@
-package com.codesquad.datastructurestudy.linkedlist;
+package com.codesquad.datastructurestudy.list.linkedlist;
 
 public class LinkedList {
     // 첫 번째 노드를 가리키는 필드
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/Main.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/Main.java
similarity index 67%
rename from hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/Main.java
rename to hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/Main.java
index fc1778e..ffacb85 100644
--- a/hamill/src/main/java/com/codesquad/datastructurestudy/linkedlist/Main.java
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/Main.java
@@ -1,4 +1,4 @@
-package com.codesquad.datastructurestudy.linkedlist;
+package com.codesquad.datastructurestudy.list.linkedlist;
 
 public class Main {
 
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/CircularLinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/CircularLinkedList.java
new file mode 100644
index 0000000..cd24529
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/CircularLinkedList.java
@@ -0,0 +1,164 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+public class CircularLinkedList {
+
+  private Node tail;
+  private int count;
+  private Node before;
+  private Node cur;
+
+  public void add(int data) {
+    Node newNode = new Node(data);
+
+    if (tail == null) {
+      tail = newNode;
+      newNode.next = newNode;
+    } else {
+      newNode.next = tail.next;
+      tail.next = newNode;
+      tail = newNode;
+    }
+    count++;
+  }
+
+  public void addName(int data, String name) {
+    Node newNode = new Node(data);
+    newNode.name = name;
+
+    if (tail == null) {
+      tail = newNode;
+      newNode.next = newNode;
+    } else {
+      newNode.next = tail.next;
+      tail.next = newNode;
+      tail = newNode;
+    }
+    count++;
+  }
+
+  public void addFront(int data) {
+    Node newNode = new Node(data);
+
+    if (tail == null) {
+      tail = newNode;
+      newNode.next = newNode;
+    } else {
+      newNode.next = tail.next;
+      tail.next = newNode;
+    }
+    count++;
+  }
+
+  public void addNameFront(int data, String name) {
+    Node newNode = new Node(data);
+    newNode.name = name;
+
+    if (tail == null) {
+      tail = newNode;
+      newNode.next = newNode;
+    } else {
+      newNode.next = tail.next;
+      tail.next = newNode;
+    }
+    count++;
+  }
+
+  public boolean first() {
+    if (tail == null) {
+      return false;
+    } else {
+      before = tail;
+      cur = tail.next;
+      return true;
+    }
+  }
+
+  public boolean next(int data) {
+    if (tail == null) {
+      return false;
+    } else {
+      before = cur;
+      cur = cur.next;
+      return true;
+    }
+  }
+
+  public int remove() {
+    Node deleteNode = cur;
+    int data = deleteNode.data;
+
+    if (deleteNode == tail) {
+      if (tail == tail.next) {
+        tail = null;
+      } else {
+        tail = before;
+      }
+    }
+
+    before.next = cur.next;
+    cur = before;
+    count--;
+    return data;
+  }
+
+  public int size() {
+    return this.count;
+  }
+
+  public String identifyWatcher(String name, int afterNum) {
+    Node searchNode = new Node();
+    searchNode.next = tail.next;
+    int count = 0;
+    String watcher = null;
+
+    while (true) {
+      if (searchNode.name == name) {
+        break;
+      } else {
+        searchNode = searchNode.next;
+        count++;
+      }
+    }
+
+    for (int i = 0; i < afterNum + count; i++) {
+      if (i != afterNum + count - 1) {
+        searchNode = searchNode.next;
+        continue;
+      } else {
+        watcher = searchNode.name;
+      }
+    }
+    return watcher;
+  }
+
+  public static void main(String[] args) {
+    CircularLinkedList members = new CircularLinkedList();
+
+    members.addName(1, "김");
+    members.addName(2, "나");
+    members.addName(3, "박");
+    members.addName(4, "이");
+
+    System.out.println("서치 시작");
+
+    System.out.println(members.identifyWatcher("김", 7));
+
+  }
+
+  private class Node {
+
+    private int data;
+    private String name;
+    private Node next;
+
+    public Node() {
+      this.data = 0;
+      this.next = null;
+    }
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/DDoublyLinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/DDoublyLinkedList.java
new file mode 100644
index 0000000..d05f560
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/DDoublyLinkedList.java
@@ -0,0 +1,74 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+public class DDoublyLinkedList {
+
+  private Node dummyNodeHead;
+  private Node dummyNodeTail;
+  private Node head;
+  private Node tail;
+  private int count;
+
+  public DDoublyLinkedList() {
+    this.dummyNodeHead = new Node(-1);
+    this.dummyNodeTail = new Node(-2);
+
+    this.dummyNodeHead.prev = null;
+    this.dummyNodeHead.next = this.dummyNodeTail;
+
+    this.dummyNodeTail.prev = dummyNodeHead;
+    this.dummyNodeTail.next = null;
+
+    this.head = this.dummyNodeHead;
+    this.tail = this.dummyNodeTail;
+  }
+
+  public void add(int data) {
+    Node newNode = new Node(data);
+    // newNode 설정
+    newNode.prev = dummyNodeTail.prev;
+    newNode.next = tail;
+    // newNode 이전 노드 설정
+    dummyNodeTail.prev.next = newNode;
+    // tail 설정
+    dummyNodeTail.prev = newNode;
+
+    count++;
+  }
+
+  public void remove() {
+    if (tail.prev == head) {
+      System.out.println("삭제할 노드가 없습니다");
+    }
+    // 꼬리에 있는 노드 삭제
+    tail.prev.prev.next = tail;
+    tail.prev = tail.prev.prev;
+    count--;
+  }
+
+  public int size() {
+    return this.count;
+  }
+
+  public static void main(String[] args) {
+
+  }
+
+
+  private class Node {
+    private int data;
+    private Node next;
+    private Node prev;
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+      this.prev = null;
+    }
+
+    public Node() {
+      this.data = 0;
+      this.next = null;
+      this.prev = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/DummyLinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/DummyLinkedList.java
new file mode 100644
index 0000000..6045c72
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/DummyLinkedList.java
@@ -0,0 +1,115 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+
+public class DummyLinkedList {
+
+  private Node dummyNode = new Node();
+  private Node head = dummyNode;
+  private Node tail = dummyNode;
+  private int count = 0;
+  private boolean comp;
+  private boolean asc;
+
+  public DummyLinkedList(boolean isTrue) {
+    this.asc = isTrue;
+  }
+
+  private int whoIsAsc(int d1, int d2) {
+    if (d1 < d2) {
+      return 0;
+    } else {
+      return 1;
+    }
+  }
+
+  public void add(int data) {
+    if (count == 0) {
+      addFirst(data);
+    } else {
+      addSecond(data);
+    }
+  }
+
+  private void addFirst(int data) {
+    Node newNode = new Node(data);
+    dummyNode.next = newNode;
+    count++;
+  }
+
+  private void addSecond(int data) {
+    Node newNode = new Node(data);
+    Node cur = new Node();
+    cur.next = dummyNode.next;
+    int index = 0;
+
+//    newNode.next = dummyNode.next;
+//    dummyNode.next = newNode;
+//    count++;
+
+    if (this.asc) {
+      while (dummyNode.next != null && cur.next != null && whoIsAsc(data, cur.next.data) != 0) {
+        cur = cur.next;
+        index++;
+      }
+    }
+
+    Node node = getNode(index-1);
+    if (node.next == null) {
+      newNode.next = null;
+      node.next = newNode;
+    } else {
+      newNode.next = node.next;
+      node.next = newNode;
+    }
+    count++;
+  }
+
+  public int remove(int index) {
+    Node deleteNode = getNode(index);
+    Node deleteNextNode = deleteNode.next;
+    Node pred = getNode(index-1);
+    pred.next = deleteNextNode;
+    count--;
+    return deleteNode.data;
+  }
+
+  public int size() {
+    return this.count;
+  }
+
+  public int get(int index) {
+    Node cur = new Node();
+    cur.next = dummyNode.next;
+    for (int i = 0; i <= index; i++) {
+      cur = cur.next;
+    }
+    return cur.data;
+  }
+
+  private Node getNode(int index) {
+    Node cur = new Node();
+    cur.next = dummyNode.next;
+    for (int i = 0; i <= index; i++) {
+      cur = cur.next;
+    }
+    return cur;
+  }
+
+  private class Node {
+    private int data;
+    private Node next;
+
+    public Node() {
+
+    }
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+    }
+
+    public String toString() {
+      return String.valueOf(this.data);
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/LinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/LinkedList.java
new file mode 100644
index 0000000..0b168dd
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/LinkedList.java
@@ -0,0 +1,83 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+import java.util.List;
+
+public class LinkedList {
+
+  private Node head;
+  private Node tail;
+  private Node cur;
+  private int size = 0;
+
+  public void add(int data) {
+    Node newNode = new Node(data);
+
+    if (head == null) {
+      head = newNode;
+    } else {
+      tail.next = newNode;
+    }
+    tail = newNode;
+  }
+
+  public void retrieve() {
+    if (head == null) {
+      System.out.println("값이 존재하지 않습니다");
+    } else {
+      int i = 1;
+      cur = head;
+      System.out.println(i + "번째 데이터 : " + cur.data);
+
+      while (cur.next != null) {
+        i++;
+        cur = cur.next;
+        System.out.println(i + "번째 데이터 : " + cur.data);
+      }
+    }
+  }
+
+  // 연결 리스트 삭제(머리에서부터)
+  public void remove() {
+    if (head == null) {
+      System.out.println("값이 존재하지 않습니다");
+    } else {
+      Node delNode = head;
+      Node delNextNode = head.next;
+
+      head = delNextNode;
+      delNode = null;
+    }
+  }
+
+  public static void main(String[] args) {
+    LinkedList list = new LinkedList();
+    list.add(1);
+    list.add(2);
+    list.add(3);
+    list.add(4);
+    list.add(5);
+
+    System.out.println("삭제 전 리스트");
+    list.retrieve();
+
+    list.remove();
+    list.remove();
+
+    System.out.println("삭제 후 리스트");
+    list.retrieve();
+  }
+
+  private class Node {
+    private int data;
+    private Node next;
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+    }
+
+    public String toString() {
+      return String.valueOf(this.data);
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/LinkedRead.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/LinkedRead.java
new file mode 100644
index 0000000..43bf448
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/LinkedRead.java
@@ -0,0 +1,79 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+import java.util.Scanner;
+
+public class LinkedRead {
+
+  private static Node head;
+  private static Node tail;
+
+  public static void main(String[] args) {
+
+
+    Node newNode = new Node();
+    Scanner scanner = new Scanner(System.in);
+//    int readData = 0;
+
+    // 데이터 입력
+    while(true) {
+      System.out.println("자연수 입력: ");
+      int num = scanner.nextInt();
+      if (num < 1) {
+        break;
+      }
+
+      newNode.data = num;
+      newNode.next = null;
+
+      if (head == null) {
+        head = newNode;
+      } else {
+        tail.next = newNode;
+      }
+
+      tail = newNode;
+    }
+    System.out.println();
+
+    // 입력 받은 데이터 출력
+    System.out.println("입력 받은 데이터의 전체 출력!");
+    if (head == null) {
+      System.out.println("저장된 자연수가 존재하지 않습니다!");
+    } else {
+      Node cur = head;
+      System.out.println(cur.data);
+
+      while (cur.next != null) {
+        cur = cur.next;
+        System.out.println(cur.data);
+      }
+    }
+
+    // 메모리 해제
+    if (head == null) {
+      return;
+    } else {
+      Node delNode = head;
+      Node delNextNode = head.next;
+
+      System.out.println(head.data + "(을)를 삭제합니다");
+
+      while (delNextNode != null) {
+        delNode = delNextNode;
+        delNextNode =delNextNode.next;
+
+        System.out.println(delNode.data + "(을)를 삭제합니다");
+      }
+    }
+  }
+
+
+  private static class Node {
+    private int data;
+    private Node next;
+
+    public Node() {
+      this.next = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/ListMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/ListMain.java
new file mode 100644
index 0000000..99dca0d
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/ListMain.java
@@ -0,0 +1,29 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+public class ListMain {
+
+  public static void main(String[] args) {
+
+    DummyLinkedList list = new DummyLinkedList(true);
+    list.add(11);
+    list.add(22);
+    list.add(11);
+    list.add(22);
+    list.add(33);
+
+    System.out.println("현재 데이터의 수: " + list.size());
+
+    for (int i = 0; i < list.size(); i++) {
+      System.out.println(list.get(i));
+    }
+
+    list.remove(1);
+    list.remove(1);
+
+    System.out.println("현재 데이터의 수: " + list.size());
+
+    System.out.println(list.get(0));;
+    System.out.println(list.get(1));;
+    System.out.println(list.get(2));;
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/Member.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/Member.java
new file mode 100644
index 0000000..e0dd267
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/Member.java
@@ -0,0 +1,7 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+public class Member {
+
+  private int number;
+  private String name;
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/Solution4_1.java b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/Solution4_1.java
new file mode 100644
index 0000000..2576fc0
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/list/linkedlist/yoon/Solution4_1.java
@@ -0,0 +1,59 @@
+package com.codesquad.datastructurestudy.list.linkedlist.yoon;
+
+import java.util.Scanner;
+
+public class Solution4_1 {
+
+  private static Node dummyNode = new Node();
+  private static Node head;
+  private static Node tail;
+
+  public static void main(String[] args) {
+    Scanner scanner = new Scanner(System.in);
+    dummyNode.data = 100;
+    dummyNode.next = null;
+    head = dummyNode;
+    tail = dummyNode;
+    int num = 0;
+
+    // 데이터 삽입
+    while(true) {
+      Node newNode = new Node();
+      System.out.print("자연수 입력 : ");
+      num = scanner.nextInt();
+      if (num < 1) {
+        break;
+      }
+
+      newNode.data = num;
+      newNode.next = null;
+
+      if (tail == dummyNode) {
+        dummyNode.next = newNode;
+        tail = newNode;
+      } else {
+        newNode.next = dummyNode.next;
+        dummyNode.next = newNode;
+      }
+    }
+
+    // 데이터 조회
+    System.out.println("입력 받은 데이터의 전체 출력!");
+    if (head == null) {
+      System.out.println("저장된 자연수가 존재하지 않습니다!");
+    } else {
+      Node cur = head;
+      System.out.println(cur.data);
+
+      while (cur.next != null) {
+        cur = cur.next;
+        System.out.println(cur.data);
+      }
+    }
+  }
+
+  private static class Node {
+    private int data;
+    private Node next;
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapImpl.java
new file mode 100644
index 0000000..1e8fdba
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapImpl.java
@@ -0,0 +1,92 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class HeapImpl {
+
+  private static final int HEAP_LEN = 100;
+  private int[] heapArr;
+  private int count;
+
+  public HeapImpl() {
+    this.heapArr = new int[HEAP_LEN];
+    this.count = 0;
+  }
+
+  private int comparePriority(int data1, int data2) {
+    if ((data2 - data1) > 0) {
+      return 1;
+    } else if ((data2 - data1) < 0) {
+      return -1;
+    }
+    return 0;
+  }
+
+  public boolean isEmpty() {
+    if (this.count == 0) {
+      return true;
+    }
+    return false;
+  }
+
+  public int getParentIndex(int index) {
+    return index / 2;
+  }
+
+  public int getLeftChildIndex(int index) {
+    return index * 2;
+  }
+
+  public int getRightChildIndex(int index) {
+    return getLeftChildIndex(index) + 1;
+  }
+
+  public int getHighPriorityChildIndex(int index) {
+    if (getLeftChildIndex(index) > this.count) {
+      return 0;
+    } else if (getLeftChildIndex(index) == this.count) {
+      return getLeftChildIndex(index);
+    } else {
+      if (comparePriority(heapArr[getLeftChildIndex(index)], heapArr[getRightChildIndex(index)]) < 0) {
+        return getRightChildIndex(index);
+      } else {
+        return getLeftChildIndex(index);
+      }
+    }
+  }
+
+  public void insert(int data) {
+    int index = this.count + 1;
+
+    while (index != 1) {
+      if (comparePriority(data, heapArr[getParentIndex(index)]) > 0) {
+        heapArr[index] = heapArr[getParentIndex(index)];
+        index = getParentIndex(index);
+      } else {
+        break;
+      }
+    }
+
+    heapArr[index] = data;
+    this.count++;
+  }
+
+  public int delete() {
+    int data = heapArr[1];
+    int lastElement = heapArr[this.count];
+
+    int parentIndex = 1;
+    int childIndex = getHighPriorityChildIndex(parentIndex);
+
+    while (childIndex != 0) {
+      if (comparePriority(lastElement, heapArr[childIndex]) >= 0) {
+        break;
+      }
+      heapArr[parentIndex] = heapArr[childIndex];
+      parentIndex = childIndex;
+      childIndex = getHighPriorityChildIndex(parentIndex);
+    }
+
+    heapArr[parentIndex] = lastElement;
+    this.count--;
+    return data;
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapMain.java
new file mode 100644
index 0000000..b41ab9d
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapMain.java
@@ -0,0 +1,22 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class HeapMain {
+
+  public static void main(String[] args) {
+    HeapImpl heap = new HeapImpl();
+
+    heap.insert(100);
+    heap.insert(200);
+    heap.insert(300);
+    System.out.println(heap.delete());
+
+    heap.insert(100);
+    heap.insert(200);
+    heap.insert(300);
+    System.out.println(heap.delete());
+
+    while (!heap.isEmpty()) {
+      System.out.println(heap.delete());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapStringImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapStringImpl.java
new file mode 100644
index 0000000..13fa08a
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/HeapStringImpl.java
@@ -0,0 +1,95 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class HeapStringImpl {
+
+  private static final int HEAP_LEN = 100;
+  private String[] heapArr;
+  private int count;
+
+  public HeapStringImpl() {
+    this.heapArr = new String[HEAP_LEN];
+    this.count = 0;
+  }
+
+  private int comparePriority(String data1, String data2) {
+    int num1 = data1.length();
+    int num2 = data2.length();
+
+    if ((num2 - num1) > 0) {
+      return 1;
+    } else if ((num2 - num1) < 0) {
+      return -1;
+    }
+    return 0;
+  }
+
+  public boolean isEmpty() {
+    if (this.count == 0) {
+      return true;
+    }
+    return false;
+  }
+
+  public int getParentIndex(int index) {
+    return index / 2;
+  }
+
+  public int getLeftChildIndex(int index) {
+    return index * 2;
+  }
+
+  public int getRightChildIndex(int index) {
+    return getLeftChildIndex(index) + 1;
+  }
+
+  public int getHighPriorityChildIndex(int index) {
+    if (getLeftChildIndex(index) > this.count) {
+      return 0;
+    } else if (getLeftChildIndex(index) == this.count) {
+      return getLeftChildIndex(index);
+    } else {
+      if (comparePriority(heapArr[getLeftChildIndex(index)], heapArr[getRightChildIndex(index)]) < 0) {
+        return getRightChildIndex(index);
+      } else {
+        return getLeftChildIndex(index);
+      }
+    }
+  }
+
+  public void insert(String data) {
+    int index = this.count + 1;
+
+    while (index != 1) {
+      if (comparePriority(data, heapArr[getParentIndex(index)]) > 0) {
+        heapArr[index] = heapArr[getParentIndex(index)];
+        index = getParentIndex(index);
+      } else {
+        break;
+      }
+    }
+
+    heapArr[index] = data;
+    this.count++;
+  }
+
+  public String delete() {
+    String data = heapArr[1];
+    String lastElement = heapArr[this.count];
+
+    int parentIndex = 1;
+    int childIndex = getHighPriorityChildIndex(parentIndex);
+
+    while (childIndex != 0) {
+      if (comparePriority(lastElement, heapArr[childIndex]) >= 0) {
+        break;
+      }
+      heapArr[parentIndex] = heapArr[childIndex];
+      parentIndex = childIndex;
+      childIndex = getHighPriorityChildIndex(parentIndex);
+    }
+
+    heapArr[parentIndex] = lastElement;
+    this.count--;
+    return data;
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueue.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueue.java
new file mode 100644
index 0000000..aafbf88
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueue.java
@@ -0,0 +1,8 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public interface PriorityQueue {
+
+  boolean isEmpty();
+  void enqueue(int data);
+  int dequeue();
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueueImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueueImpl.java
new file mode 100644
index 0000000..fefcf01
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueueImpl.java
@@ -0,0 +1,22 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class PriorityQueueImpl implements PriorityQueue {
+
+  HeapImpl heap;
+
+  public PriorityQueueImpl() {
+    heap = new HeapImpl();
+  }
+
+  public boolean isEmpty() {
+    return heap.isEmpty();
+  }
+
+  public void enqueue(int data) {
+    heap.insert(data);
+  }
+
+  public int dequeue() {
+    return heap.delete();
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueueMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueueMain.java
new file mode 100644
index 0000000..7d1ae76
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityQueueMain.java
@@ -0,0 +1,22 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class PriorityQueueMain {
+
+  public static void main(String[] args) {
+    PriorityQueueImpl priorityQueue = new PriorityQueueImpl();
+
+    priorityQueue.enqueue(100);
+    priorityQueue.enqueue(200);
+    priorityQueue.enqueue(300);
+    System.out.println(priorityQueue.dequeue());
+
+    priorityQueue.enqueue(100);
+    priorityQueue.enqueue(200);
+    priorityQueue.enqueue(300);
+    System.out.println(priorityQueue.dequeue());
+
+    while (!priorityQueue.isEmpty()) {
+      System.out.println(priorityQueue.dequeue());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityStringQueueImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityStringQueueImpl.java
new file mode 100644
index 0000000..cbb909b
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityStringQueueImpl.java
@@ -0,0 +1,22 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class PriorityStringQueueImpl {
+
+  HeapStringImpl heap;
+
+  public PriorityStringQueueImpl() {
+    heap = new HeapStringImpl();
+  }
+
+  public boolean isEmpty() {
+    return heap.isEmpty();
+  }
+
+  public void enqueue(String data) {
+    heap.insert(data);
+  }
+
+  public String dequeue() {
+    return heap.delete();
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityStringQueueMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityStringQueueMain.java
new file mode 100644
index 0000000..cee3a6b
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/PriorityStringQueueMain.java
@@ -0,0 +1,22 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class PriorityStringQueueMain {
+
+  public static void main(String[] args) {
+    PriorityStringQueueImpl priorityStringQueue = new PriorityStringQueueImpl();
+
+    priorityStringQueue.enqueue("1");
+    priorityStringQueue.enqueue("12");
+    priorityStringQueue.enqueue("123");
+    System.out.println(priorityStringQueue.dequeue());
+
+    priorityStringQueue.enqueue("1");
+    priorityStringQueue.enqueue("12");
+    priorityStringQueue.enqueue("123");
+    System.out.println(priorityStringQueue.dequeue());
+
+    while (!priorityStringQueue.isEmpty()) {
+      System.out.println(priorityStringQueue.dequeue());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeap.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeap.java
new file mode 100644
index 0000000..bc83506
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeap.java
@@ -0,0 +1,8 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public interface SimpleHeap {
+
+  boolean isEmpty();
+  void insert(int data, int priority);
+  int delete();
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeapImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeapImpl.java
new file mode 100644
index 0000000..3f27662
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeapImpl.java
@@ -0,0 +1,99 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class SimpleHeapImpl implements SimpleHeap {
+
+  private static final int HEAP_LEN = 100;
+  private HeapElement[] heapArr;
+  private int count;
+
+  public SimpleHeapImpl() {
+    heapArr = new HeapElement[HEAP_LEN];
+    this.count = 0;
+  }
+
+  public boolean isEmpty() {
+    if (this.count == 0) {
+      return true;
+    }
+    return false;
+  }
+
+  public int getParentIndex(int index) {
+    return index / 2;
+  }
+
+  public int getLeftChildIndex(int index) {
+    return index * 2;
+  }
+
+  public int getRightChildIndex(int index) {
+    return getLeftChildIndex(index) + 1;
+  }
+
+  public int getHighPriorityChildIndex(int index) {
+    if (getLeftChildIndex(index) > count) {
+      return 0;
+    } else if (getLeftChildIndex(index) == count) {
+      return getLeftChildIndex(index);
+    } else {
+      if (heapArr[getLeftChildIndex(index)].priority > heapArr[getRightChildIndex(index)].priority) {
+        return getRightChildIndex(index);
+      } else {
+        return getLeftChildIndex(index);
+      }
+    }
+  }
+
+  public void insert(int data, int priority) {
+    int index = count + 1;
+    HeapElement he = new HeapElement(data, priority);
+
+    while (index != 1) {
+      if (priority < heapArr[getParentIndex(index)].priority) {
+        heapArr[index] = heapArr[getParentIndex(index)];
+        index = getParentIndex(index);
+      } else {
+        break;
+      }
+    }
+
+    heapArr[index] = he;
+    count++;
+  }
+
+  public int delete() {
+    int data = heapArr[1].data;
+    HeapElement lastHeapElement = heapArr[count];
+    int parentIndex = 1;
+    int childIndex = getHighPriorityChildIndex(parentIndex);
+//    heapArr[parentIndex] = lastHeapElement;
+
+    while (childIndex != 0) {
+      if (lastHeapElement.priority <= heapArr[childIndex].priority) {
+        break;
+      }
+      heapArr[parentIndex] = heapArr[childIndex];
+      parentIndex = childIndex;
+      childIndex = getHighPriorityChildIndex(parentIndex);
+    }
+
+    heapArr[parentIndex] = lastHeapElement;
+    count--;
+    return data;
+  }
+
+  private class HeapElement {
+    private int data;
+    private int priority;
+
+    public HeapElement() {
+      this.data = 0;
+      this.priority = 0;
+    }
+
+    public HeapElement(int data, int priority) {
+      this.data = data;
+      this.priority = priority;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeapMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeapMain.java
new file mode 100644
index 0000000..6e26aa2
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/priorityqueue/SimpleHeapMain.java
@@ -0,0 +1,22 @@
+package com.codesquad.datastructurestudy.queue.priorityqueue;
+
+public class SimpleHeapMain {
+
+  public static void main(String[] args) {
+    SimpleHeapImpl heap = new SimpleHeapImpl();
+
+    heap.insert(100, 1);
+    heap.insert(200, 2);
+    heap.insert(300, 3);
+    System.out.println(heap.delete());
+
+    heap.insert(100, 1);
+    heap.insert(200, 2);
+    heap.insert(300, 3);
+    System.out.println(heap.delete());
+
+    while(!heap.isEmpty()) {
+      System.out.println(heap.delete());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/CircularQueue.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/CircularQueue.java
new file mode 100644
index 0000000..97f743a
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/CircularQueue.java
@@ -0,0 +1,59 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public class CircularQueue implements Queue {
+
+  private int front;
+  private int rear;
+  public int QUEUE_LENGTH = 100;
+  private int[] queueArr;
+
+  public CircularQueue() {
+    this.front = 0;
+    this.rear = 0;
+    this.queueArr = new int[QUEUE_LENGTH];
+  }
+
+  public boolean isEmpty() {
+    if (this.front == this.rear) {
+      return true;
+    }
+    return false;
+  }
+
+  public int nextPositionIndex(int position) {
+    if (position == QUEUE_LENGTH - 1) {
+      return 0;
+    } else {
+      return position + 1;
+    }
+  }
+
+  public void enqueue(int data) {
+    if (nextPositionIndex(this.rear) == this.front) {
+      System.out.println("Queue Memory Error!");
+      return;
+    }
+
+    this.rear = nextPositionIndex(rear);
+    this.queueArr[this.rear] = data;
+  }
+
+  public int dequeue() {
+    if (isEmpty()) {
+      System.out.println("Queue Memory Error!");
+      return -1;
+    }
+
+    this.front = nextPositionIndex(front);
+    return queueArr[front];
+  }
+
+  public int peek() {
+    if (isEmpty()) {
+      System.out.println("Stack Memory Error!");
+      return -1;
+    }
+
+    return queueArr[nextPositionIndex(front)];
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/Deque.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/Deque.java
new file mode 100644
index 0000000..9427da0
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/Deque.java
@@ -0,0 +1,12 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public interface Deque {
+
+  boolean isEmpty();
+  void addFirst(int data);
+  void addLast(int data);
+  int removeFirst();
+  int removeLast();
+  int getFirst();
+  int getLast();
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeBaseQueue.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeBaseQueue.java
new file mode 100644
index 0000000..4c3485f
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeBaseQueue.java
@@ -0,0 +1,47 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public class DequeBaseQueue {
+
+  private Node head;
+  private Node tail;
+  private DequeDoublyLinkedList deque = new DequeDoublyLinkedList();
+
+  public DequeBaseQueue() {
+    this.head = null;
+    this.tail = null;
+  }
+
+  public boolean isEmpty() {
+    return deque.isEmpty();
+  }
+
+  public void enqueue(int data) {
+    deque.addLast(data);
+  }
+
+  public int dequeue() {
+    return deque.removeFirst();
+  }
+
+  public int peek() {
+    return deque.getFirst();
+  }
+
+  private class Node {
+    private int data;
+    private Node next;
+    private Node prev;
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+      this.prev = null;
+    }
+
+    public Node() {
+      this.data = 0;
+      this.next = null;
+      this.prev = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeBaseQueueMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeBaseQueueMain.java
new file mode 100644
index 0000000..cd5af24
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeBaseQueueMain.java
@@ -0,0 +1,18 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public class DequeBaseQueueMain {
+
+  public static void main(String[] args) {
+    DequeBaseQueue queue = new DequeBaseQueue();
+
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+    queue.enqueue(4);
+    queue.enqueue(5);
+
+    while (!queue.isEmpty()) {
+      System.out.println(queue.dequeue());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeDoublyLinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeDoublyLinkedList.java
new file mode 100644
index 0000000..3d0a788
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeDoublyLinkedList.java
@@ -0,0 +1,105 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+import java.awt.print.Pageable;
+
+public class DequeDoublyLinkedList implements Deque{
+
+  private Node head;
+  private Node tail;
+
+  public DequeDoublyLinkedList() {
+    this.head = null;
+    this.tail = null;
+  }
+
+  public boolean isEmpty() {
+    if (head == null || tail == null) {
+      return true;
+    }
+    return false;
+  }
+
+  public void addFirst(int data) {
+    Node newNode = new Node(data);
+
+    if (isEmpty()) {
+      tail = newNode;
+    } else {
+      newNode.next = head;
+      head.prev = newNode;
+    }
+    head = newNode;
+  }
+
+  public void addLast(int data) {
+    Node newNode = new Node(data);
+
+    if (isEmpty()) {
+      head = newNode;
+    } else {
+      newNode.prev = tail;
+      tail.next = newNode;
+    }
+    tail = newNode;
+  }
+
+  public int removeFirst() {
+    Node delNode = head;
+
+    if (isEmpty()) {
+      System.out.println("Deque Memory Error!");
+      return -1;
+    } else {
+      delNode.prev = null;
+      head = delNode.next;
+      return delNode.data;
+    }
+  }
+
+  public int removeLast() {
+    Node delNode = tail;
+
+    if (isEmpty()) {
+      System.out.println("Deque Memory Error!");
+      return -1;
+    } else {
+      delNode.next = null;
+      tail = delNode.prev;
+      return delNode.data;
+    }
+  }
+
+  public int getFirst() {
+    if (isEmpty()) {
+      return -1;
+    } else {
+      return head.data;
+    }
+  }
+
+  public int getLast() {
+    if (isEmpty()) {
+      return -1;
+    } else {
+      return tail.data;
+    }
+  }
+
+  private class Node {
+    private int data;
+    private Node next;
+    private Node prev;
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+      this.prev = null;
+    }
+
+    public Node() {
+      this.data = 0;
+      this.next = null;
+      this.prev = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeMain.java
new file mode 100644
index 0000000..5a1b18f
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/DequeMain.java
@@ -0,0 +1,36 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public class DequeMain {
+
+  public static void main(String[] args) {
+    DequeDoublyLinkedList deque = new DequeDoublyLinkedList();
+
+    System.out.println("데이터 넣기 1차");
+    deque.addFirst(3);
+    deque.addFirst(2);
+    deque.addFirst(1);
+
+    deque.addLast(4);
+    deque.addLast(5);
+    deque.addLast(6);
+
+    System.out.println("데이터 꺼내기 1차");
+    while (!deque.isEmpty()) {
+      System.out.println(deque.removeFirst());
+    }
+
+    System.out.println("데이터 넣기 2차");
+    deque.addFirst(3);
+    deque.addFirst(2);
+    deque.addFirst(1);
+
+    deque.addLast(4);
+    deque.addLast(5);
+    deque.addLast(6);
+
+    System.out.println("데이터 꺼내기 2차");
+    while(!deque.isEmpty()) {
+      System.out.println(deque.removeLast());
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/HamburgerSim.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/HamburgerSim.java
new file mode 100644
index 0000000..ff81d90
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/HamburgerSim.java
@@ -0,0 +1,54 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+import java.util.Random;
+
+public class HamburgerSim {
+
+  private static final int CUS_COME_TERM = 15;
+  private static final int CHE_BUR = 0;
+  private static final int BUL_BUR = 1;
+  private static final int DUB_BUR = 2;
+  private static final int CHE_TERM = 12;
+  private static final int BUL_TERM = 15;
+  private static final int DUB_TERM = 24;
+
+  public static void main(String[] args) {
+    int makeProcess = 0;
+    int cheOrder = 0;
+    int bulOrder = 0;
+    int dubOrder = 0;
+    int sec;
+
+    CircularQueue queue = new CircularQueue();
+    Random random = new Random();
+
+    for (sec = 0; sec < 3600; sec++) {
+      if (sec % CUS_COME_TERM == 0) {
+        switch (random.nextInt(10) % 3) {
+          case CHE_BUR:
+            queue.enqueue(CHE_TERM);
+            cheOrder++;
+            break;
+          case BUL_BUR:
+            queue.enqueue(BUL_TERM);
+            bulOrder++;
+            break;
+          case DUB_BUR:
+            queue.enqueue(DUB_TERM);
+            dubOrder++;
+            break;
+        }
+      }
+      if (makeProcess <= 0 && !queue.isEmpty()) {
+        makeProcess = queue.dequeue();
+      }
+      makeProcess--;
+    }
+
+    System.out.println("Simulation Report!");
+    System.out.println(" - Cheese burger : " + cheOrder);
+    System.out.println(" - Bulgogi burger : " + bulOrder);
+    System.out.println(" - Double burger : " + dubOrder);
+    System.out.println(" - Waiting room size : " + queue.QUEUE_LENGTH);
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/LinkedBaseQueue.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/LinkedBaseQueue.java
new file mode 100644
index 0000000..395b00b
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/LinkedBaseQueue.java
@@ -0,0 +1,67 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public class LinkedBaseQueue implements Queue {
+
+  private Node front;
+  private Node rear;
+
+  public LinkedBaseQueue() {
+    this.front = null;
+    this.rear = null;
+  }
+
+  public boolean isEmpty() {
+    if (front == null) {
+      return true;
+    }
+    return false;
+  }
+
+  public void enqueue(int data) {
+    Node newNode = new Node(data);
+
+    if (isEmpty()) {
+      front = newNode;
+    } else {
+      rear.next = newNode;
+    }
+    rear = newNode;
+  }
+
+  public int dequeue() {
+    Node delNode;
+
+    if (isEmpty()) {
+      System.out.println("Queue Memory Error!");
+      return -1;
+    } else {
+      delNode = front;
+      front = delNode.next;
+      return delNode.data;
+    }
+  }
+
+  public int peek() {
+    if (isEmpty()) {
+      System.out.println("Queue Memory Error!");
+      return -1;
+    } else {
+      return front.data;
+    }
+  }
+
+  private class Node {
+    private int data;
+    private Node next;
+
+    public Node() {
+      this.data = 0;
+      this.next = null;
+    }
+
+    public Node(int data) {
+      this.data = data;
+      this.next = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/Queue.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/Queue.java
new file mode 100644
index 0000000..41addc0
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/Queue.java
@@ -0,0 +1,9 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public interface Queue {
+
+  boolean isEmpty();
+  void enqueue(int data);
+  int dequeue();
+  int peek();
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/QueueMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/QueueMain.java
new file mode 100644
index 0000000..e36c1a8
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/queue/yoon/QueueMain.java
@@ -0,0 +1,19 @@
+package com.codesquad.datastructurestudy.queue.yoon;
+
+public class QueueMain {
+
+  public static void main(String[] args) {
+//    CircularQueue queue = new CircularQueue();
+    LinkedBaseQueue queue = new LinkedBaseQueue();
+
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+    queue.enqueue(4);
+    queue.enqueue(5);
+
+    while (!queue.isEmpty()) {
+      System.out.print(queue.dequeue() + " ");
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/Factorial.java b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/Factorial.java
new file mode 100644
index 0000000..ffe21ad
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/Factorial.java
@@ -0,0 +1,15 @@
+package com.codesquad.datastructurestudy.recursive;
+
+public class Factorial {
+
+  private static int factorial(int number) {
+    if (number == 0) {
+      return 1;
+    }
+    return number * factorial(number-1);
+  }
+
+  public static void main(String[] args) {
+    System.out.println(factorial(5));
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/FibonacciFunction.java b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/FibonacciFunction.java
new file mode 100644
index 0000000..bf465a5
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/FibonacciFunction.java
@@ -0,0 +1,21 @@
+package com.codesquad.datastructurestudy.recursive;
+
+public class FibonacciFunction {
+
+  private static int fibonacci(int number) {
+
+    System.out.println("func call param " + number);
+
+    if (number == 1) {
+      return 0;
+    } else if (number == 2) {
+      return 1;
+    }
+
+    return fibonacci(number-1) + fibonacci(number-2);
+  }
+
+  public static void main(String[] args) {
+    fibonacci(7);
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/HanoiTower.java b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/HanoiTower.java
new file mode 100644
index 0000000..7d48882
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/HanoiTower.java
@@ -0,0 +1,18 @@
+package com.codesquad.datastructurestudy.recursive;
+
+public class HanoiTower {
+
+  private static void moveHanoiTower(int number, String from, String by, String to) {
+    if (number == 1) {
+      System.out.println("원반 " + number + "를 " + from + "에서 " + to + "로 이동");
+    } else {
+      moveHanoiTower(number-1, from,to, by);
+      System.out.println("원반 " + number + "를 " + from + "에서 " + to + "로 이동");
+      moveHanoiTower(number-1, by, from, to);
+    }
+  }
+
+  public static void main(String[] args) {
+    moveHanoiTower(3, "A", "B", "C");
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/RecursiveBinarySearch.java b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/RecursiveBinarySearch.java
new file mode 100644
index 0000000..1f33291
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/RecursiveBinarySearch.java
@@ -0,0 +1,33 @@
+package com.codesquad.datastructurestudy.recursive;
+
+import java.util.Arrays;
+
+public class RecursiveBinarySearch {
+
+  private static int recursiveBSearch(int[] numbers, int first, int last, int target) {
+
+    if (first > last) {
+      return -1;
+    }
+
+    int mid = (first + last) / 2;
+    if (numbers[mid] == target) {
+      return mid;
+    } else if (numbers[mid] < target) {
+      return recursiveBSearch(numbers, mid + 1, last, target);
+    } else {
+      return recursiveBSearch(numbers, first, mid - 1, target);
+    }
+  }
+
+  public static void main(String[] args) {
+    int[] numbers = {1,2,3,4,5,6,7,8,9};
+    int[] numbers1 = new int[5000];
+    Arrays.fill(numbers1, 0);
+
+    int index1 = recursiveBSearch(numbers1, 0, numbers1.length-1, 50);
+    int index = recursiveBSearch(numbers, 0, numbers.length-1, 9);
+    System.out.println(index);
+    System.out.println(index1);
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/RecursiveFunction.java b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/RecursiveFunction.java
new file mode 100644
index 0000000..b742e4b
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/recursive/RecursiveFunction.java
@@ -0,0 +1,16 @@
+package com.codesquad.datastructurestudy.recursive;
+
+public class RecursiveFunction {
+
+  private static void recursive(int number) {
+    if (number <= 0) {
+      return;
+    }
+    System.out.println("Recursive call!" + number);
+    recursive(number-1);
+  }
+
+  public static void main(String[] args) {
+    recursive(3);
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/Calculator.java b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/Calculator.java
new file mode 100644
index 0000000..a9150c7
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/Calculator.java
@@ -0,0 +1,135 @@
+package com.codesquad.datastructurestudy.stack.yoon;
+
+public class Calculator {
+
+  public String converterToRPNExp(String exp) {
+    StackCircularLinkedList stack = new StackCircularLinkedList();
+    int expLen = exp.length();
+    StringBuilder converterExp = new StringBuilder("");
+
+    int index = 0;
+    char tok;
+    char popOp;
+
+    for (int i = 0; i < expLen; i++) {
+      tok = exp.charAt(i);
+
+      if (Character.isDigit(tok)) {
+        converterExp.append(tok);
+        index++;
+      } else {
+        switch (tok) {
+          case '(':
+            stack.push(String.valueOf(tok));
+            break;
+          case ')':
+            while(true) {
+              popOp = stack.pop().charAt(0);
+              if (popOp == '(') {
+                break;
+              }
+              converterExp.append(popOp);
+              index++;
+            }
+            break;
+          case '+': case '-':
+          case '*': case '/':
+            while (!stack.isEmpty() && whoPrecOperation(stack.peek().charAt(0), tok) >= 0) {
+              converterExp.append(stack.pop());
+              index++;
+            }
+            stack.push(String.valueOf(tok));
+            break;
+        }
+      }
+    }
+
+    while (!stack.isEmpty()) {
+      converterExp.append(stack.pop());
+      index++;
+    }
+    return exp = converterExp.toString();
+  }
+
+  public int getOperationPrec(char op) {
+    switch (op) {
+      case '*':
+      case '/':
+        return 5;
+      case '+':
+      case '-':
+        return 3;
+      case '(':
+        return 1;
+    }
+    return -1;
+  }
+
+  public int whoPrecOperation(char op1, char op2) {
+    int op1Prec = getOperationPrec(op1);
+    int op2Prec = getOperationPrec(op2);
+
+    if (op1Prec > op2Prec) {
+      return 1;
+    } else if (op1Prec < op2Prec) {
+      return -1;
+    } else {
+      return 0;
+    }
+  }
+
+  public String evalRPNExp(String exp) {
+    StackCircularLinkedList stack = new StackCircularLinkedList();
+    int expLen = exp.length();
+    char tok;
+    int num1;
+    int num2;
+
+    for (int i = 0; i < expLen; i++) {
+      tok = exp.charAt(i);
+      if (Character.isDigit(tok)) {
+        stack.push(String.valueOf(tok));
+      } else {
+        num2 = Integer.valueOf(stack.pop());
+        num1 = Integer.valueOf(stack.pop());
+
+        switch (tok) {
+          case '+':
+            stack.push(String.valueOf(num1 + num2));
+            break;
+          case '-':
+            stack.push(String.valueOf(num1 - num2));
+          case '*':
+            stack.push(String.valueOf(num1 * num2));
+            break;
+          case '/':
+            stack.push(String.valueOf(num1 / num2));
+            break;
+        }
+      }
+    }
+    return stack.pop();
+  }
+
+  public static void main(String[] args) {
+    Calculator calculator = new Calculator();
+    String exp1 = "1+2*3";
+    String exp2 = "(1+2)*3";
+    String exp3 = "((1-2)+3)*(5-2)";
+
+    exp1 = calculator.converterToRPNExp(exp1);
+    exp2 = calculator.converterToRPNExp(exp2);
+    exp3 = calculator.converterToRPNExp(exp3);
+
+    System.out.println(exp1);
+    System.out.println(exp2);
+    System.out.println(exp3);
+
+    String postExp1 = "42*8+";
+    String postExp2 = "123+*4/";
+
+    System.out.printf("%s = %s\n", postExp1, calculator.evalRPNExp(postExp1));
+    System.out.printf("%s = %s\n", postExp2, calculator.evalRPNExp(postExp2));
+
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/Stack.java b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/Stack.java
new file mode 100644
index 0000000..ed5ecbd
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/Stack.java
@@ -0,0 +1,9 @@
+package com.codesquad.datastructurestudy.stack.yoon;
+
+public interface Stack {
+
+  boolean isEmpty();
+  void push(int data);
+  int pop();
+  int peek();
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackArrayImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackArrayImpl.java
new file mode 100644
index 0000000..d7f9d8b
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackArrayImpl.java
@@ -0,0 +1,39 @@
+package com.codesquad.datastructurestudy.stack.yoon;
+
+public class StackArrayImpl implements Stack {
+
+  private int[] stackArr;
+  private int topIndex;
+
+  public StackArrayImpl() {
+    this.stackArr = new int[10];
+    this.topIndex = -1;
+  }
+
+  public boolean isEmpty() {
+    if (topIndex == -1) {
+      return true;
+    }
+    return false;
+  }
+
+  public void push(int data) {
+    stackArr[++topIndex] = data;
+  }
+
+  public int pop() {
+    if (isEmpty()) {
+      System.out.println("Stack Memory Error!");
+      return -1;
+    }
+    return stackArr[topIndex--];
+  }
+
+  public int peek() {
+    if (isEmpty()) {
+      System.out.println("Stack Memory Error!");
+      return -1;
+    }
+    return stackArr[topIndex];
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackCircularLinkedList.java b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackCircularLinkedList.java
new file mode 100644
index 0000000..d3db198
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackCircularLinkedList.java
@@ -0,0 +1,67 @@
+package com.codesquad.datastructurestudy.stack.yoon;
+
+public class StackCircularLinkedList {
+
+  private Node tail;
+  private int count;
+
+  public StackCircularLinkedList() {
+    this.tail = null;
+  }
+
+  public boolean isEmpty() {
+    if (tail == null) {
+      return true;
+    }
+    return false;
+  }
+
+  public void push(String data) {
+    Node newNode = new Node(data);
+
+    if (tail == null) {
+      newNode.next = newNode;
+      tail = newNode;
+    } else {
+      newNode.next = tail.next;
+    }
+    tail.next = newNode;
+
+    count++;
+  }
+
+  public String pop() {
+    if (tail == null) {
+      System.out.println("Stack Memory Error!");
+      return null;
+    } else {
+      Node delNode = tail.next;
+      if (tail.next == tail) {
+        tail = null;
+      } else {
+        tail.next = delNode.next;
+      }
+      count--;
+      return delNode.data;
+    }
+  }
+
+  public String peek() {
+    if (tail == null) {
+      System.out.println("Stack Memory Error!");
+      return null;
+    } else {
+      return tail.next.data;
+    }
+  }
+
+  private class Node {
+    private String data;
+    private Node next;
+
+    public Node(String data) {
+      this.data = data;
+      this.next = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackLinkedListImpl.java b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackLinkedListImpl.java
new file mode 100644
index 0000000..6e65171
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackLinkedListImpl.java
@@ -0,0 +1,66 @@
+package com.codesquad.datastructurestudy.stack.yoon;
+
+import com.codesquad.datastructurestudy.tree.yoon.BinaryTreeNode;
+
+public class StackLinkedListImpl {
+
+  private Node head;
+
+  public StackLinkedListImpl() {
+    this.head = null;
+  }
+
+  public boolean isEmpty() {
+    if (head == null) {
+      return true;
+    }
+    return false;
+  }
+
+  public void push(BinaryTreeNode data) {
+    Node newNode = new Node(data);
+    newNode.next = head;
+    head = newNode;
+  }
+
+  public BinaryTreeNode pop() {
+    BinaryTreeNode delData;
+    Node delNode;
+
+    if (isEmpty()) {
+      System.out.println("Stack Memory Error!");
+      return null;
+    }
+
+    delData = head.data;
+    delNode = head;
+
+    head = head.next;
+    delNode = null;
+    return delData;
+  }
+
+  public BinaryTreeNode peek() {
+    if (isEmpty()) {
+      System.out.println("Stack Memory Error!");
+      return null;
+    }
+
+    return head.data;
+  }
+
+  private class Node {
+    private BinaryTreeNode data;
+    private Node next;
+
+    public Node(BinaryTreeNode data) {
+      this.data = data;
+      this.next = null;
+    }
+
+    public Node() {
+      this.data = null;
+      this.next = null;
+    }
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackMain.java
new file mode 100644
index 0000000..3f000d8
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/stack/yoon/StackMain.java
@@ -0,0 +1,77 @@
+package com.codesquad.datastructurestudy.stack.yoon;
+
+public class StackMain {
+
+  public static void main(String[] args) {
+    StackCircularLinkedList stack = new StackCircularLinkedList();
+//    Stack stack = new StackLinkedListImpl();
+//    Stack stack = new StackArrayImpl();
+
+    System.out.println("스택이 비었습니까?");
+    System.out.println(stack.isEmpty());
+
+    System.out.println("스택 삽입");
+//    stack.push(1);
+//    stack.push(2);
+//    stack.push(3);
+//    stack.push(4);
+//    stack.push(5);
+    stack.push("1");
+    stack.push("2");
+    stack.push("3");
+    stack.push("4");
+    stack.push("5");
+    stack.push("6");
+
+    System.out.println("스택 삽입 후");
+    System.out.println("스택이 비었습니까?");
+    System.out.println(stack.isEmpty());
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후4");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후3");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후2");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    stack.pop();
+    System.out.println("스택 삭제 후1");
+    System.out.println("스택 제일 위의 값은?");
+    System.out.println(stack.peek());
+
+    char ch1 = '1';
+    char ch2 = '2';
+    int num1 = Character.getNumericValue(ch1);
+    int num2 = Character.getNumericValue(ch2);
+    System.out.println("char 연산");
+    System.out.println(num1 + num2);
+    System.out.println(num1 - num2);
+    System.out.println(num1 * num2);
+    System.out.println(num1 / num2);
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTree.java b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTree.java
new file mode 100644
index 0000000..aaf050f
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTree.java
@@ -0,0 +1,10 @@
+package com.codesquad.datastructurestudy.tree.yoon;
+
+public interface BinaryTree {
+  int getData();
+  void setData(int data);
+  BinaryTreeNode getLeftSubTree();
+  BinaryTreeNode getRightSubTree();
+  void makeLeftSubTree(BinaryTreeNode main, BinaryTreeNode sub);
+  void makeRightSubTree(BinaryTreeNode main, BinaryTreeNode sub);
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTreeMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTreeMain.java
new file mode 100644
index 0000000..e4639d0
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTreeMain.java
@@ -0,0 +1,100 @@
+package com.codesquad.datastructurestudy.tree.yoon;
+
+public class BinaryTreeMain {
+
+  public static void inorderTraverse(BinaryTreeNode btn) {
+    if (btn == null) {
+      return;
+    }
+
+    if (btn.getLeftSubTree() != null || btn.getRightSubTree() != null) {
+      System.out.print("( ");
+    }
+      inorderTraverse(btn.getLeftSubTree());
+      showIntData(btn.getData());
+      inorderTraverse(btn.getRightSubTree());
+
+    if (btn.getLeftSubTree() != null || btn.getRightSubTree() != null) {
+    System.out.print(") ");
+    }
+  }
+
+  public static void preorderTraverse(BinaryTreeNode btn) {
+    if (btn == null) {
+      return;
+    }
+
+    showIntData(btn.getData());
+    preorderTraverse(btn.getLeftSubTree());
+    preorderTraverse(btn.getRightSubTree());
+  }
+
+  public static void postorderTraverse(BinaryTreeNode btn) {
+    if (btn == null) {
+      return;
+    }
+
+    postorderTraverse(btn.getLeftSubTree());
+    postorderTraverse(btn.getRightSubTree());
+    showIntData(btn.getData());
+  }
+
+  public static void showIntData(Object data) {
+    System.out.print(data + " ");
+  }
+
+  public static void deleteTree(BinaryTreeNode btn) {
+    if (btn == null) {
+      return;
+    }
+
+    System.out.println("삭제되는 값 : " + btn.getData());
+    deleteTree(btn.getLeftSubTree());
+    deleteTree(btn.getRightSubTree());
+    btn.setData(0);
+    btn = null;
+  }
+
+  public static void main(String[] args) {
+    BinaryTreeNode bt1 = new BinaryTreeNode();
+    BinaryTreeNode bt2 = new BinaryTreeNode();
+    BinaryTreeNode bt3 = new BinaryTreeNode();
+    BinaryTreeNode bt4 = new BinaryTreeNode();
+    BinaryTreeNode bt5 = new BinaryTreeNode();
+    BinaryTreeNode bt6 = new BinaryTreeNode();
+
+    bt1.setData(1);
+    bt2.setData(2);
+    bt3.setData(3);
+    bt4.setData(4);
+    bt5.setData(5);
+    bt6.setData(6);
+
+    bt1.makeLeftSubTree(bt1, bt2);
+    bt1.makeRightSubTree(bt1, bt3);
+    bt2.makeLeftSubTree(bt2, bt4);
+    bt2.makeRightSubTree(bt2, bt5);
+    bt3.makeRightSubTree(bt3, bt6);
+
+    //1
+    System.out.println("bt1의 왼쪽 자식 노드의 데이터 출력 : " + bt1.getLeftSubTree().getData());
+    System.out.println("bt2의 왼쪽 자식 노드의 왼쪽 자식 노드의 데이터 출력 : "
+        + bt2.getLeftSubTree().getData());
+
+    //2
+//    inorderTraverse(bt1);
+
+    //3
+    preorderTraverse(bt1);
+    System.out.println();
+    inorderTraverse(bt1);
+    System.out.println();
+    postorderTraverse(bt1);
+    System.out.println();
+
+    //4
+    deleteTree(bt1);
+    System.out.println(bt1.getLeftSubTree().getData());
+    System.out.println(bt1.getRightSubTree().getData());
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTreeNode.java b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTreeNode.java
new file mode 100644
index 0000000..b501200
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/BinaryTreeNode.java
@@ -0,0 +1,49 @@
+package com.codesquad.datastructurestudy.tree.yoon;
+
+public class BinaryTreeNode {
+
+  private Object data;
+  private BinaryTreeNode left;
+  private BinaryTreeNode right;
+
+  public BinaryTreeNode(Object data) {
+    this.data = data;
+    this.left = null;
+    this.right = null;
+  }
+
+  public BinaryTreeNode() {
+    this.left = null;
+    this.right = null;
+  }
+
+  public Object getData() {
+    return  this.data;
+  }
+
+  public void setData(Object data) {
+    this.data = data;
+  }
+
+  public BinaryTreeNode getLeftSubTree() {
+    return this.left;
+  }
+
+  public BinaryTreeNode getRightSubTree() {
+    return this.right;
+  }
+
+  public void makeLeftSubTree(BinaryTreeNode main, BinaryTreeNode sub) {
+    if (main.left != null) {
+      main.left = null;
+    }
+    main.left = sub;
+  }
+
+  public void makeRightSubTree(BinaryTreeNode main, BinaryTreeNode sub) {
+    if (main.right != null) {
+      main.right = null;
+    }
+    main.right = sub;
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTree.java b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTree.java
new file mode 100644
index 0000000..4bb8c79
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTree.java
@@ -0,0 +1,9 @@
+package com.codesquad.datastructurestudy.tree.yoon;
+
+public interface ExpressionTree {
+  BinaryTreeNode makeExpTree(String exp);
+  int evaluateExpTree(BinaryTreeNode btn);
+  void showPrefixTypeExp(BinaryTreeNode btn);
+  void showInfixTypeExp(BinaryTreeNode btn);
+  void showPostfixTypeExp(BinaryTreeNode btn);
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTreeMain.java b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTreeMain.java
new file mode 100644
index 0000000..da777b6
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTreeMain.java
@@ -0,0 +1,24 @@
+package com.codesquad.datastructurestudy.tree.yoon;
+
+public class ExpressionTreeMain {
+
+  public static void main(String[] args) {
+    String exp = "12+7*";
+    ExpressionTreeNode expTreeNode = new ExpressionTreeNode();
+    BinaryTreeNode bTreeNode = expTreeNode.makeExpTree(exp);
+
+    System.out.print("전위 표기법의 수식 : ");
+    BinaryTreeMain.preorderTraverse(bTreeNode);
+
+    System.out.println();
+    System.out.print("중위 표기법의 수식 : ");
+    expTreeNode.showInfixTypeExp(bTreeNode);
+
+    System.out.println();
+    System.out.print("후위 표기법의 수식 : ");
+    expTreeNode.showPostfixTypeExp(bTreeNode);
+
+    System.out.println();
+    System.out.println("연산의 결과 : " + expTreeNode.evaluateExpTree(bTreeNode));
+  }
+}
diff --git a/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTreeNode.java b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTreeNode.java
new file mode 100644
index 0000000..7e5a44d
--- /dev/null
+++ b/hamill/src/main/java/com/codesquad/datastructurestudy/tree/yoon/ExpressionTreeNode.java
@@ -0,0 +1,66 @@
+package com.codesquad.datastructurestudy.tree.yoon;
+
+import com.codesquad.datastructurestudy.stack.yoon.StackLinkedListImpl;
+
+public class ExpressionTreeNode extends BinaryTreeNode implements ExpressionTree {
+
+  public BinaryTreeNode makeExpTree(String exp) {
+    StackLinkedListImpl stack = new StackLinkedListImpl();
+
+    for (int i = 0; i < exp.length(); i++) {
+      String ch = exp.substring(i,i+1);
+      if (Character.isDigit(ch.charAt(0))) {
+        BinaryTreeNode node = new BinaryTreeNode(Character.getNumericValue(ch.charAt(0)));
+        stack.push(node);
+      } else {
+        BinaryTreeNode node = new BinaryTreeNode();
+        BinaryTreeNode btn1 = stack.pop();
+        BinaryTreeNode btn2 = stack.pop();
+
+        node.makeRightSubTree(node, btn1);
+        node.makeLeftSubTree(node, btn2);
+        node.setData(ch);
+        stack.push(node);
+      }
+    }
+    return stack.pop();
+  }
+
+  public int evaluateExpTree(BinaryTreeNode btn) {
+
+    BinaryTreeNode btn1 = btn.getLeftSubTree();
+    BinaryTreeNode btn2 = btn.getRightSubTree();
+
+    if (btn1 == null && btn2 == null) {
+      return Integer.parseInt(btn.getData().toString());
+    }
+
+    int operation1 = evaluateExpTree(btn1);
+    int operation2 = evaluateExpTree(btn2);
+
+    switch (btn.getData().toString()) {
+      case "+":
+        return operation1 + operation2;
+      case "-":
+        return operation1 - operation2;
+      case "*":
+        return operation1 * operation2;
+      case "/":
+        return operation1 / operation2;
+    }
+
+    return 0;
+  }
+
+  public void showPrefixTypeExp(BinaryTreeNode btn) {
+    BinaryTreeMain.preorderTraverse(btn);
+  }
+
+  public void showInfixTypeExp(BinaryTreeNode btn) {
+    BinaryTreeMain.inorderTraverse(btn);
+  }
+
+  public void showPostfixTypeExp(BinaryTreeNode btn) {
+    BinaryTreeMain.postorderTraverse(btn);
+  }
+}