리스트 인터페이스 확인하기
```java
/**
*
* @author andpact
* @param the type of elements it this list
*
*/
public interface List {
/**
* 지정된 인덱스에 지정된 요소를 삽입합니다.
* @param index 요소를 삽입할 인덱스
* @param element 삽입할 요소
*/
void add(int index, E element);
/**
* 지정된 인덱스의 요소를 반환합니다.
* @param i 반환할 요소의 인덱스
* @return 반환할 요소
*/
E get(int i);
// UPDATE
/**
* 지정한 위치의 요소를 지정한 요소로 교체합니다.
* @param i 변경될 요소의 인덱스
* @param e 새로운 요소
*/
void set(int i, E e);
/**
* 지정한 인덱스의 요소를 제거합니다.
* @param index 삭제할 요소의 인덱스
*/
void remove(int index);
/**
* 첫 요소부터 탐색하여 지정한 요소가 존재한다면 해당 요소를 삭제합니다.
* @param e 삭제할 요소
*/
void remove(E e);
/**
* 모든 요소를 삭제합니다.
*/
void clear();
/**
* 지정한 요소를 포함하고 있다면 true를 반환합니다.
* @param o 포함 여부를 확인할 객체
* @return 지정된 객체를 포함하고 있다면 true를 반환
*/
boolean contains(Object o);
/**
* 지정된 요소의 인덱스를 반환합니다. 없다면 -1을 반환합니다.
* @param o 인덱스를 확인할 요소
* @return 지정된 객체가 존재한다면 해당 객체의 인덱스 반환, 그렇지 않으면 -1 반환
*/
int indexOf(Object o);
/**
* 요소를 포함하고 있지 않다면 true를 반환합니다.
* @return 요소를 포함하고 있지 않다면 true 반환
*/
boolean isEmpty();
/**
* 요소의 개수를 반홥합니다.
* @return 요소의 개수 반환
*/
int size();
}
```
</details>
## **노드 클래스**
```java
/**
* @author andpact
* @param the type of elements it this SinglyNode
*/
public class SinglyNode {
public E val;
public SinglyNode next;
public SinglyNode(E val) {
this.val = val;
this.next = null;
}
}
```
## **생성자**
```java
public class SinglyLinkedList implements List {
private SinglyNode head;
private int size;
public SinglyLinkedList() {
this.head = null;
this.size = 0;
}
}
```
## **CREATE 메서드**
```java
@Override
public void add(int index, E element) {
if (index < 0 || size < index)
throw new IndexOutOfBoundsException();
else if (index == 0) { // addFirst
SinglyNode newNode = new SinglyNode<>(element);
newNode.next = head;
head = newNode;
size++;
return;
}
SinglyNode prev = getNode(index - 1);
SinglyNode newNode = new SinglyNode<>(element);
newNode.next = prev.next;
prev.next = new SinglyNode<>(element);
size++;
}
```
## **READ 메서드**
```java
@Override
public E get(int i) {
return getNode(i).val;
}
public SinglyNode getNode(int index) {
if (index < 0 || size <= index)
return null;
SinglyNode cur = head;
for (int i = 0; i < index; i++)
cur = cur.next;
return cur;
}
```
## **UPDATE 메서드**
```java
@Override
public void set(int i, E e) {
if (i < 0 || size <= i)
throw new IndexOutOfBoundsException();
getNode(i).val = e;
}
```
## **DELETE 메서드**
```java
@Override
public void remove(int index) {
if (index < 0 || size <= index)
throw new IndexOutOfBoundsException();
else if (index == 0) { // removeFirst
head = head.next;
size--;
return;
}
SinglyNode cur = head;
for (int i = 0; i < index - 1; i++)
cur = cur.next;
cur.next = cur.next.next;
size--;
}
@Override
public void remove(E e) {
SinglyNode cur = head;
for (int i = 0; i < size; i++) {
if (cur.val.equals(e)) {
remove(i);
return;
} cur = cur.next;
}
}
@Override
public void clear() {
SinglyNode cur = head;
for (int i = 0; i < size; i++) {
SinglyNode next = cur.next;
cur.val = null;
cur.next = null;
cur = next;
}
size = 0;
}
```
## **기타 메서드**
```java
@Override
public boolean contains(Object o) {
return indexOf(o) != -1;
}
@Override
public int indexOf(Object o) {
SinglyNode cur = head;
for (int i = 0; i < size; i++) {
if (cur.val.equals(o)) return i;
cur = cur.next;
}
return -1;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public int size() {
return size;
}
```
Leave a comment