자료구조 - Linked List ( 링크드 리스트)

1. linked list... 조금씩 어려워 진다. 하지만 걱정말자!

연결리스트라고도 하는 이 구조는 순차적으로 연결된 공간에 데이터를 나열하는 배열과는 다르게, 떨어진 곳에 존재하는 데이터를 열결해서 관리하는 데이터 구조. C에서 많이 사용되는 구조이지만 공부하는 입장에서 알아두면 좋겠다.

 

2. 본론

 

 1) 기본 구조와 용어

(출처: wikipedia,  https://en.wikipedia.org/wiki/Linked_list )

 

노드 - 데이터 저장 단위로 구성.

포인터 - 각 노드 안에서 다음이나 이전 노드와의 연결 정보를 가지고 있는 공간

 

장점은 미리 공간을 할당하지 않아도 됨.

단점은 연결을 위한 별도의 공간이 필요하므로 공간에 대한 효율성이 낮음

연결정보를 찾아야하기때문에 속도가 느림,

중간 데이터를 삭제하면 데이터의 연결을 재구성해야함.

 

단일연결리스트와 이중 연결 리스트, 원형 연결 리스트가 존재함.

 - 단일연결리스트

각 노드가 다음 노드에 대해서만 참조하는 가장 단순한 형태의 연결 리스트. Head 노드를 잃어버리면 데이터 전체를 사용못하게 되는 단점이 존재함. FAT 파일시스템에서 파일청크를 연결할때 사용

- 이중연결 리스트

각 노드가 이전노드와 다음노드에 대해서 참조함. 삭제가 간편하며 단일연결리스트에 비해 데이터손상에는 강하지만 관리할 참조가 2개이므로 삽입이나 정렬의 경우 작업량이 더 많아짐.

- 원형연결리스트

마지막 요소가 첫번째 요소를 참조함. 스트림버퍼 구현에 많이 사용됨.

 

 

 2) 구현

public class Main {
    public static void main(String[] args) {

        LinkedList l = new LinkedList(0);
        l.addFirst(1);
        l.add(0,2);
        l.addLast(5);
        l.addLast(56);
        l.addLast(8);
        l.addLast("gj");
        l.addLast("nnv");
        l.addLast(555);
        l.print();
        System.out.println("--------------");
        l.delHead(); // 2
        l.delLast(); // 555
        l.del(2); // 5
        l.del(2); // 56
        l.del(2); // 8
        l.del(0); // 1
        l.print();

    }
}

class LinkedList{
    private Node head;
    private Node tail;
    private int size =0;

    public LinkedList(Object obj){
        head = new Node(obj);
        tail = null;
        size++;
    }

    public void addFirst(Object obj){
        Node node = new Node(obj);
        node.next = head;
        head = node;
        size++;
    }
    public void add(int idx, Object obj){
        if (idx>size){
            throw new RuntimeException();
        }
        Node node = new Node(obj);
        node.next =get(idx);
        if(idx<1){
            head = node;
        }
        else{
            get(idx-1).next = node;
        }
        size++;
    }
    public void addLast(Object obj){
        Node node = new Node(obj);
        node.next = null;
        get(size-1).next=node;
        size++;
    }
    public void delHead(){
        Node rmNode = head;
        head = head.next;
        rmNode = null;
        size--;
    }
    public void del(int idx){
        Node rmNode = get(idx);
        if(idx>size) throw new RuntimeException();
        if(rmNode.next!=null && idx>0) get(idx-1).next = rmNode.next;
        else if(rmNode.next!=null && idx<1) head = rmNode.next;
        else if(rmNode.next==null ) get(idx-1).next = null;
        rmNode = null;
        size--;
    }
    public void delLast(){
        Node rmNode = get(size-1);
        get(size-2).next = null;
        rmNode = null;
        size--;
    }


    public void print(){
        for (int i=0; i<size;i++){
            System.out.println(get(i).data);
        }
    }
    public Object getData(int index){
        return this.get(index).data;
    }
    public Node get(int index){
        Node node = head;
        for (int i=0;i<index; i++){
            node = node.next;
        }
        return node;
    }

    class Node{
        private Object data;
        private Node next;
        public Node(Object obj){
            this.data = obj;
            this.next = null;
        }
    }
}

//  result
//2
//1
//0
//5
//56
//8
//gj
//nnv
//555
//--------------
//0
//gj
//nnv

 

구현하다보니 길었다... 휴..