LinkedList 입문 부터 입 토 까지

목차
  • LinkedList 입문 부터 입 토 까지
  • 안내
  • 등급 구조
  • 관건 적 인 구조
  • 노드 (Node)
  • 방법
  • 구조 함수
  • 증가 방법
  • addFirst(E e)
  • addLast (E e) 와 add (E e)
  • add(int index,E element)
  • addAll(Collection extends E>c)
  • 삭제 방법
  • remove 와 removeFirst
  • removeLast
  • remove(int index)
  • remove(Object o)
  • 원소 세트 수정 (int index Eelement)
  • 원소 찾기
  • getFirst()
  • getLast()
  • get(int index)
  • indexOf(Object o)
  • 옮 겨 다 니 며 집합
  • for circle
  • 교체 기
  • foreach 순환
  • LinkedList 입문 부터 입 토 까지
    간단 한 소개
    먼저 배열 과 마찬가지 로 LinkedList 도 선형 데이터 구조 로 링크 로 이 루어 진 집합 이 고 요소 가 질서 가 있 으 며 null 로 중복 할 수 있 습 니 다.
    메모리 의 동적 분 배 를 허용 하기 때문에 메모리 분 배 는 컴 파일 러 가 실 행 될 때 이 루어 진 다 는 것 을 의미 합 니 다. LinkedList 가 설명 할 때 크기 를 지정 할 필요 가 없습니다.
    또한 연속 적 인 위치 에 요 소 를 저장 할 필요 가 없다. 노드 는 다음 노드 나 이전 노드 를 참조 하여 삽입 하고 삭제 하 는 비용 이 매우 낮 기 때문이다.
    LinkedList 의 실현 은 양 방향 링크 를 바탕 으로 하 며, 헤드 노드 에 데 이 터 를 저장 하지 않 습 니 다.
    Array List 와 마찬가지 로 동기 화 용기 가 아 닙 니 다.
    계층 구조
    [외부 체인 이미지 저장 에 실 패 했 습 니 다. 원본 사이트 에 도 난 방지 체인 메커니즘 이 있 을 수 있 습 니 다. 그림 을 저장 해서 직접 업로드 하 는 것 을 권장 합 니 다 (img - SAFdrM8w - 1597210837179) (https://raw.githubusercontent.com/iszhonghu/Picture-bed/master/img/20200811170511.png)]
  • 클론 과 직렬 화 를 지원 하 는 Cloneable 인터페이스 와 Serializable 인 터 페 이 스 를 실현 했다.
  • AbstractSequentia List 를 계승 하 는 양 방향 링크 이기 때문에 스 택, 대기 열 또는 두 개의 대기 열 로 조작 할 수 있 습 니 다
  • List 인 터 페 이 스 를 실현 하기 때문에 대기 열 작업 을 할 수 있 습 니 다
  • Deque 인터페이스 가 구현 되 었 기 때문에 LinkedList 를 양 단 대기 열 로 사용 할 수 있 습 니 다
  • 관건 구조
    노드 (노드)
    LinkedList 의 모든 요 소 는 노드 라 고 할 수 있 습 니 다. 모든 노드 는 세 개의 항목 을 포함 합 니 다. 하 나 는 요소 자체 이 고 다른 하 나 는 하나의 요소 와 같은 인용 주 소 를 실행 하 는 것 입 니 다. 셋 째 는 이전 요소 의 인용 주 소 를 가리 키 는 것 입 니 다.
    Node 는 LinkedList 류 의 개인 적 인 정적 내부 클래스 입 니 다.
    private static class Node<E> {
            E item;//       
            Node<E> next;
            Node<E> prev;
    
            Node(Node<E> prev, E element, Node<E> next) {
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
        }
    

    방법.
    구조 함수
    LinkedList 는 두 개의 구조 함수 가 있 습 니 다. 하 나 는 기본 적 인 빈 구조 함수 입 니 다. 하 나 는 기 존 요소 의 집합 Collection 의 인 스 턴 스 를 LinkedList 에 추가 하고 addAll 방법 을 호출 합 니 다.
    증가 방법
    LinkedList 는 많은 add 방법 이 있 지만 매번 요 소 를 추가 할 때마다 해당 노드 의 상하 포인터 참조 만 바 꾸 고 확장 되 지 않 아서 효율 이 좋 습 니 다.
    addFirst(E e)
    지정 한 요 소 를 체인 헤더 에 추가 합 니 다.
    public void addFirst(E e) {
            linkFirst(e);
        }
     private void linkFirst(E e) {
            final Node<E> f = first;//        f
            final Node<E> newNode = new Node<>(null, e, f);//             ,                  
            first = newNode;
            if (f == null)
                last = newNode;
            else
                f.prev = newNode;
            size++;
            modCount++;
        }
    

    addLast (E e) 와 add (E e)
    삽입 헤드 노드 와 차이 가 많 지 않 고 논리 적 차원 이 대체적으로 같다.
     void linkLast(E e) {
            final Node<E> l = last;
            final Node<E> newNode = new Node<>(l, e, null);
            last = newNode;
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }
    

    add(int index,E element)
    지정 한 요 소 를 이 목록 의 지정 한 위치 에 삽입 합 니 다.
    addAll(Collection extends E>c)
    지정 한 집합 교체 기 가 돌아 오 는 순서에 따라 지정 한 집합 중의 모든 요 소 를 이 목록 의 끝 에 추가 합 니 다.
    삭제 방법
    요 소 를 삭제 하 는 것 과 요 소 를 추가 하 는 것 은 대체적으로 일치 합 니 다. 즉, 해당 요소 가 이전 노드 와 다음 노드 를 가리 키 는 인용 을 바 꾸 면 됩 니 다.
    remove 와 removeFirst
    목록 에서 첫 번 째 요 소 를 제거 하고 이 요 소 를 되 돌려 줍 니 다.
    removeLast
    목록 에서 마지막 요 소 를 삭제 하고 이 요 소 를 되 돌려 줍 니 다.
    remove(int index)
    이 목록 에서 지정 한 위치의 요 소 를 삭제 합 니 다.
    remove(Object o)
    존재 한다 면 이 목록 에서 지정 한 요 소 를 삭제 하 는 첫 번 째 출현
    요소 세트 수정 (int index Eelement)
    이 목록 에서 지정 한 위치의 요 소 를 지정 한 요소 로 대체 합 니 다. 주로 node (index) 방법 으로 지정 한 색인 위치의 몇 가 지 를 얻 은 다음 에 이 노드 위치의 요 소 를 수정 합 니 다.
    원소 찾기
    getFirst()
    이 목록 의 첫 번 째 요 소 를 되 돌려 줍 니 다.
    getLast()
    이 목록 의 마지막 요 소 를 되 돌려 줍 니 다.
    get(int index)
    지정 한 색인 에 있 는 요 소 를 되 돌려 줍 니 다.
    indexOf(Object o)
    이 목록 에서 지정 한 요소 가 처음 나타 난 색인 을 되 돌려 줍 니 다. 이 목록 에 요소 가 포함 되 어 있 지 않 으 면 - 1 을 되 돌려 줍 니 다.
    편력 집합
    주의해 야 할 것 은 modCount 필드 입 니 다. 앞에서 우 리 는 요 소 를 추가 하고 삭제 할 때 자체 증가 작업 modCount 를 합 니 다. 이것 은 교체 하면 서 집합 자체 의 방법 으로 삭제 하거나 추가 작업 을 하려 면 이상 을 던 지기 때 문 입 니 다.(교체 기 를 사용 한 추가 삭제 방법 은 이상 하지 않 습 니 다)
    for 순환
    get (int index) 방법 을 주로 이용 합 니 다.
    교체 기
    Iterator<String> listIt = linkedList.listIterator();
     9 while(listIt.hasNext()){
    10     System.out.print(listIt.next()+" ");
    11 }
    12 
    13 //            ,         
    14 Iterator<String> it = linkedList.descendingIterator();
    15 while(it.hasNext()){
    16     System.out.print(it.next()+" ");
    17 }
    

    그 집합 에 도 내부 클래스 Listlr 가 있 습 니 다.
    foreach 순환
    그 밑바닥 에서 사용 하 는 것 도 교체 기의 본질 과 같다
    교체 기와 for 순환 효율 차이
    일반 for 순환: 색인 요 소 를 옮 겨 다 니 기 전에 모든 색인 에 접근 합 니 다.
    16 System.out.print(it.next()+" "); 17 }
    
    ​	            Listltr,
    
    ##### foreach  
    
                   
    
    >     for      
    >
    >   for  :            ,           
    >
    >    :          ,                ,      ,      
    

    좋은 웹페이지 즐겨찾기