단일 연결 목록 및 간단한 코드의 아이디어를 실현

package com.algorithm.tiger.linkedlist; 

/ ** 
 * 연결된 목록 (연결된 여러 노드로 구성됨) 
 * 
 * @description : 단일 연결 목록 
 * @author : tiger 
 * @create : 2020-07-11 11:05 
 * / 
public class MyLinkedList { 

    // 
    링크드리스트 
    의 선두에있는 프라이빗 노드 헤드; 
// 링크드리스트의 끝에있는 
    프라이빗 노드 꼬리; 

    // 링크드리스트 의 실제 크기 
    private int size; 

    public Node find (int index) { 
        // 비정상 조건 예측 
        if (index <0 | | index> size) { 
            throw new IndexOutOfBoundsException ( "연결된 목록 노드의 범위를 벗어났습니다!"); 
        } 

        if (size == 0) { 
            // 빈 연결 목록 
            반환 null; 
        } else if (인덱스 == 0) {
            // Head 
            return head; 

        } else if (size == index) { 
            // Tail 
            return tail; 
        } else { 
            // 중간 (인덱스의 노드 노드에 도달 할 때까지 헤드에서 순회) 
            Node targetNode = head; 
            for (int i = 0; i <index; i ++) { 
                targetNode = targetNode.next; 
            } 
            return targetNode; 
        } 
    } 

    / ** 
     * 삽입 요소 (머리 삽입, 중간 삽입, 꼬리 삽입) 
     * 
     * @param data 
     * @param index 
     * @return 
     * / 
    public Node insert (int data, int index) { 

        // 비정상 상태 예측 
        if (index <0 || index> size) {
            throw new IndexOutOfBoundsException ( "연결된 목록 노드의 범위를 벗어 
        났습니다 !"); 
        } 

        // 삽입 된 노드 Node insertNode = new Node (data); 

        if (size == 0) { 
            // Empty linked list 
            head = insertNode; 
            tail = insertNode; 
        } else if (index == 0) { 
            // 헤드 삽입 
            // 1. 새 노드의 다음 포인터를 원래 헤드 노드에 가리 킵니다. 
            insertNode.next = head; 
            // 2. 새 노드를 연결 목록의 헤드 노드 
            head = insertNode; 

        } else if (size == index) { 
            // 꼬리를 삽입 
            // 1. 원래 꼬리 노드의 다음 노드를 새 노드로 지정  
            tail.next = insertNode;
            // 2. 새 노드를 가리 킵니다. 꼬리 노드에 노드 
            tail = insertNode; 
        } else {
            // 중간 삽입 (연결된 목록의 검색 방법에 의존) 

            Node prevNode = find (index-1); 
            Node currentNode = prevNode.next; 
            prevNode.next = insertNode; 
            insertNode.next = currentNode; 

            // Refresh from back to front 
// 노드 prevNode = find (index-1); 
// // 1. 삽입 위치에있는 노드를 가리키는 새 노드의 다음 포인터 (1과 2는 반전 될 수 없음) 
// insertNode.next = prevNode.next; 
// // 2. 삽입 위치에있는 이전 노드 
의 다음 포인터, 새 노드를 가리킴 // prevNode.next = insertNode; 

        } 
        size ++; 
        // 삽입 된 새 노드 데이터 
        반환 return insertNode; 
    } 

    / ** 
     * 요소 삭제, 삭제 된 노드 반환 
     * @return 
     *
     * @param index 
     * / 
    public Node remove (int index) { 
        // 비정상 조건 예측 
        if (index <0 || index> size) { 
            throw new IndexOutOfBoundsException ( "연결된 목록 노드의 범위를 벗어났습니다!"); 
        } 

        Node removeNode = null; 
        if (size == 0) { 
            // 빈 연결 목록 

        } else if (index == 0) { 
            // 헤드 제거 
            removeNode = head; 
            head = head.next; 
        } else if (size == index) { 
            // 꼬리 
            노드 제거 prevNode = find (index-1); 
            removeNode = prevNode.next; 
            prevNode.next = null; 
            tail = prevNode;
        } else {  
            // 중간 삭제 (연결된 목록 검색 방법에 의존)
            노드 prevNode = find (index-1); 
            노드 nextNode = prevNode.next.next; 
            removeNode = prevNode.next; 
            prevNode.next = nextNode; 
        } 
        크기-; 
        removeNode를 반환합니다. 
    } 

    public Node getHead () { 
        return head; 
    } 

    public void setHead (노드 헤드) { 
        this.head = 헤드; 
    } 

    public Node getTail () { 
        return tail; 
    } 

    public void setTail (노드 테일) { 
        this.tail = tail; 
    } 

    public int getSize () { 
        return size; 
    } 

    public void setSize (int size) { 
        this.size = size; 
    } 

    @Override 
    public String toString () { 
        return "MyNode {"+ 
                "head ="+ head + 
                ", tail ="+ tail + 
                ", size ="+ size + 
                '}'; 
    } 

    / ** 
     * 노드 내부 클래스 
     * / 
    private static class Node { 
        // 현재 노드 데이터 
        private int data; 
        // Next node 
        private Node next; 

        public Node () { 
        } 

        public Node (int data) { 
            this.data = data;
        } 

        public int getData () {
            반환 데이터; 
        }

        public void setData (int data) { 
            this.data = data; 
        } 

        public Node getNext () { 
            return next; 
        } 

        public void setNext (Node next) { 
            this.next = next; 
        } 

        @Override 
        public String toString () { 
            return "Node {"+ 
                    "data ="+ data + 
                    ", next ="+ next + 
                    '}'; 
        } 
    } 

    / ** 
     * 测试
     * 
     * @param args 
     * / 
    public static void main (String [] args) { 
        Node node = new Node (12);

        MyLinkedList linkedList = new MyLinkedList (); 
        linkedList.insert (12, 0); 
        linkedList.insert (122, 0); 
        linkedList.insert (343, 0); 
        linkedList.insert (1243, 1); 
        linkedList.insert (444444, 1); 
        linkedList.insert (45678, 1); 
        linkedList.insert (333333, 1); 
        System.out.println (linkedList); 
        System.out.println ( "=================="); 
// System.out.println (linkedList.find (2)); 
// linkedList.remove (0); 
// linkedList.remove (0); 
        linkedList.remove (3);
        System.out.println (linkedList); 
        System.out.println ( "==================");
// LinkedList linkedList1 = new LinkedList (); 
    } 
}