단순 연결리스트(Simple Linked List)

List.java

//List 인터페이스,<T>는 타입
public interface List<T> {
    //임의의 위치에 데이터 삽입
    public boolean add(T data, int index);
    //맨 첫번째에 데이터 삽입
    public boolean addFirst(T data);
    //맨 마지막에 데이터 삽입
    public boolean addLast(T data);
    //맨 끝에 데이터 삽입
    public boolean add(T data);
    //인덱스 값을 통해 임의 위치 값 줄력
    public T get(int index);
    //리스트의 크기 값
    public int size();
    //마지막 리스트 의 값 출력
    public T getLast();
    //맨 첫번째 리스트의 값 출력
    public T getFirst();
    //임의 위치에 삭제
    public T remove(int index);
    //첫번째 위치 삭제
    public T removeFirst();
    //마지막 위치 삭제
    public T removeLast();
    //마지막 위치 삭제
    public T remove();
    
    
    
}

LinkedList.java

package min.java.begin;
 
//연결리스트
public class LinkedLists<T> implements Lists<T> {
    //클래스 노드 
    private static class Node<T> {
 
        private T data;
        private Node<T> next;
        //생성자
        Node() {
            data = null;
            next = null;
        }
        //생성자
        Node(final T data) {
            this.data = data;
            this.next = null;
        }
    }
    //리스트 노드의 header
    private Node<T> header = null;
    //리스트의 사이즈 값
    private int size;
    //생성자
    LinkedLists() {
        //객체 생성
        header = new Node<T>();
        size = 0;
    }
    //첫번째 위치 데이터 추가 
    @Override
    public boolean addFirst(T data) {
        Node<T> newNode = new Node<T>(data);
        //리스트에 데이터가 존재하지 않는다면 맨첫번째 위치에 데이터를 추가하는 것.
        if (header == null) {
            header.next = newNode;
            size++;
            return true;
        } else {
            //리스트가 존재하면 기존의 맨앞에 있는 데이터를 뒤로 넘기고 새로운 노드를 앞에 생성
            newNode.next = header.next;
            header.next = newNode;
            size++;
            return true;
        }
    }
    //마지막 위치 데이터 주가
    @Override
    public boolean addLast(T data) {
        if (size == 0) {
            addFirst(data);
            return true;
        } else {
            add(data, size);
            return true;
        }
    }
    //마지막 위치 데이터 주가
    @Override
    public boolean add(T data) {
        add(data, size);
        return true;
    }
    //임의의 위치 데이터 추가
    @Override
    public boolean add(T data, int index) {
        if (index == 0) {
            addFirst(data);
            return true;
        }
        //새로운 노드 생성
        Node<T> newNode = new Node<T>(data);
        //임의의 위치 이전노드
        Node<T> prev = getNode(index - 1);
        //임의의 위치 다음노드
        Node<T> next = prev.next;
        
        // 리스트 중간에 데이터를 삽입하는 과정
        prev.next = newNode;
        newNode.next = next;
        size++;
        return true;
    }
    //임의 위치 리스트 값 출력
    @Override
    public T get(int index) {
        return getNode(index).data;
    }
    //첫번째 리스트 값 출력
    @Override
    public T getFirst() {
        return getNode(0).data;
    }
    //마지막 리스트의 값 출력
    @Override
    public T getLast() {
        return getNode(size - 1).data;
    }
    //모든 리스트의 값 출력
    @Override
    public String toString() {
        Node<T> temp = header.next;
        if (temp == null) {
            return "[ ]";
        } else {
            //StringBuilder 클래스를 이용하여 데이터를 출력
            StringBuilder sb = new StringBuilder("[");
            sb.append(temp.data);
            temp = temp.next;
            while (temp != null) {
                sb.append(", ");
                sb.append(temp.data);
                temp = temp.next;
            }
            sb.append("]");
            return sb.toString();
        }
    }
    //리스트의 개수 출력
    @Override
    public int size() {
        return size;
    }
    //임의의 위치 삭제
    @Override
    public T remove(int index) {
        if (index > size) {
            throw new IndexOutOfBoundsException("Index overflow is " + index + ", size is " + size);
        }
        if (size <= 0 || index < 0) {
            throw new IndexOutOfBoundsException("Not data error, size is " + size);
        } else if (index == 0) {
            return removeFirst();
        } else {
            Node<T> prev = getNode(index - 1);
            Node<T> remove = prev.next;
            prev.next = remove.next;
            size--;
            return remove.data;
        }
    }
    //첫번째 위치 삭제
    @Override
    public T removeFirst() {
        if (size <= 0) {
            throw new IndexOutOfBoundsException("Not data error, size is " + size);
        } else {
            Node<T> temp = getNode(0);
            header.next = temp.next;
            size--;
            return temp.data;
        }
 
    }
    //마지막 위치 삭제
    @Override
    public T removeLast() {
        if (size <= 0) {
            throw new IndexOutOfBoundsException("Not data error, size is " + size);
        } else {
            return remove(size - 1);
        }
    }
    //마지막 위치 삭제
    @Override
    public T remove() {
        return removeLast();
    }
    public Node<T> getNode(int index) {
        //인덱스값이 -1이거나  인덱스가 사이즈보다 크다면 Exception 에러 출력
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("index is : " + index + "size : " + size);
        }
        Node<T> move = header.next;
        int i = 0;
        //index 위치까지 노드 이동
        while (i < index) {
            move = move.next;
            i++;
        }
        return move;
    }
 
}