• • • • '요약' 을 (를) '에 비해 더 많은 라일리스트 라데크' 이 '사용' 링케드리스트 좋습니다. # 39, re 않을 경우, nbsp; &amp you& sure&amp mdash;; 그냥 '라일리스트' 로 시작합니다.

'링케드리스트' 와 '라일리스트 구축' 는 서로 다른 두 나열하십시오 인터페이스입니다. it with a '는' 링케드리스트 두 링크됨 목록. 라일리스트 '는' 으로 다시 크기 조정 무중단으로 어레이입니다.

표준 연결 리스트 마찬가지로 여러 가지 방법 및 어레이입니다 운영체, 알고리즘 런타임을 다를 수 있습니다.

장치당 ',' LinkedList&lt, E&gt

• '프레젠테이션이든 (int index)' 가 O (n) ( 를 평균 n/4 단계를)
• • • '추가 (E 요소점)' 가 O (1)
• '추가 (int index ᄆ씨 요소점)' 가 O (n) ( 를 n/4 걸음을 평균) 그러나 O (1) '-' 때 ',' 주요 장점은, E&gt LinkedList&lt &lt 인덱스화할 = 0;
• '제거 (int index)' 가 O (n) ( 를 평균 n/4 단계를)
• • • '트레이터스레모프 ()' 가 O (1). 주요 장점은 ',' E&gt LinkedList&lt < -;
• • • '리스티에라토리아다 (E 요소점)' 가 O (1) ',' 의 주요 이점은 LinkedList&lt E&gt 중의 하나다.

&lt, sup&gt, 참고: 상수입니다 n/4 단계를 하는 작업 중 많은 수가 평균 최상 단계는 n/2 단계에 있으며, (예를 들면 인덱스화할 = 0) (최악인 가운데 목록) &lt /sup>;

2 의 [E&gt ArrayList&lt, ',']

• • • '프레젠테이션이든 (int index)' 가 O (1) ',' 주요 장점은 ArrayList&lt E&gt < -;
• '추가 O (1) 상각 (E 요소점)' 가 있지만, O (n) 및 복사됨 이후 최악의 어레이입니다 크기조정 있어야 합니다.
• '추가 (int index ᄆ씨 요소점)' 가 O (n) ( 를 평균 n/2 단계를)
• '제거 (int index)' 가 O (n) ( 를 평균 n/2 단계를)
• • • '트레이터스레모프 ()' 가 O (n) ( 를 n/2 단계를 평균)
• '리스티에라토리아다 (E 요소점)' 가 O (n) ( 를 평균 n/2 단계를)

&lt, sup&gt, 참고: , N/2 단계를 하는 작업 중 많은 수가 평균 상수입니다 , n 단계를 최상 단계는 (end of 목록) 최악의 경우 (시작 목록) &lt /sup>;

, 반복자를 사용하는 ',' LinkedList&lt E&gt 순차식 액세스하도록 아니라, 일정 시간 삽입 또는 제거 가능 요소. 즉, 당신이 찾는 목록에서 앞뒤로 목록에 걸을 수 있지만, 포지셔닝하십시오 크기에 비례하는 시간이 명단요 말하고 있는 javadoc &quot 꽂으십시오 목록으로, 작업을 처음부터 끝까지 인덱스화할 트래버스할 목록 중 현재 closer&quot, 그러니까 그 방법을 모두 , 또는 O (n), 평균적으로 O (1) ( n/4 단계) = 0 '의' 인덱스화할 표시되어도.

반면, ',' ArrayList&lt E&gt 읽을 수 있도록 빠른 랜덤 액세스 할 수 있는 시스템을 모든 요소에 상수입니다 하게하면서요. 그러나 변화하는 모든 요소를 추가하거나 제거할 수 있지만 어디서부터든 및끝 单捞磐啊 rmw 끝날거요 인컨텍스트 열어 또는 칠합니다 끊겨있다. 또한 기본 요소를 어레이이며 용량보다 더 추가하면 새로운 어레이입니다 (1.5 배 크기) 은 나이가 어레이입니다 복사됩니다 할당할지, 라일리스트 '는' O (n), 새 검사점 그러하매 충족되었으며 추가 최악의 경우 하지만 상수입니다 있는 것으로 나타났다.

그래서 않으려면 구축 작업을 하면, 그에 따라 선택해야 합니다. 두 종류의 목록은 똑같이 반복 비해 싼 셈이다. (반복 통해 '라일리스트' 는 기술적으로 빠르지만 않으면 you& # 39, re 일을 정말 성능에 민감한 전날에약혼자에게 shouldn& # 39, t # 39 이 대화상자와 they& 걱정해야 하고, 모두 상수입니다.)

링케드리스트 발생할 경우 기존 반복자를 사용하는 주된 이점은 '및' 재사용률이 삽입하려면 요소를 제거합니다. 이러한 작업을 수행할 수 있는 O (1) 변경하여 로컬로만 목록. , 이동할 필요가 있는 경우 나머지 어레이입니다 어레이에서는 목록 (즉 복사됨). On the other side '있다' 는 다음과 같은 인할지 링케드리스트 해당 링크를 O (n) ( n/2 단계) 에 있는 반면, 라일리스트 수학적으로 원하는 위치를 계산할 수 있는 최악의 '및' 에서 액세스되는 O (1) .

또 다른 장점은 '수장' 에서 추가하거나 제거하면 사용하여 링케드리스트 발생할 수 있으므로, 이러한 작업은 목록 O (1) 'O (n) 에 있는 동안, 라일리스트'. 참고로, '좋은 대안이 될 수 있다' 는 '링케드리스트 라데크' 를 추가 / 제거 에서 헤드입니다 아니다 '는' 목록.

또한, 많은 경우, 또 다른 메모리 사용량은 열거합니다 점에 유의해야 합니다. 각 요소에 '' 는 더 링케드리스트 오버헤드에 포인터는 다음 및 이전 요소도 저장됩니까. # 39 이 오버헤드에 ',' 라일리츠 don& 없다. 그러나 '' 에 할당된 메모리 용량을 많이 차지할 라일리츠 그대로 여부에 관계없이 요소가 실제로 추가되었습니다.

초기 용량은 매우 작은 (Java 에서 10 라일리스트 '기본' 1.4-1.8). 하지만 이 어레이에는 배열입니다 기반 시스템 구축, 이후 많은 요소를 추가한 크기조정 합니다. # 39 you& 크기조정 피하기 위해 많은 비용이 많이 알고 있을 때, re 추가할 계획입니다 요소, 라일리스트 chunghwa 는 '' 더 높은 초기 용량을.

지금까지 아니예 것으로 ruettgers 는 메모리 공간 외에 각 않는다는 데 의견을 모으고 있는 ',' 는 이러한 열거합니다 일반 링케드리스트 &quot 많이 more&quot. 그래서 내가 얼마나 정확히 입증할 수 있는 '라일리스트 비해 몇 가지 수치 연산 모두 자신만을 위해 시행하십시오 열거합니다 ᄂ씨 nulll 참조입니다.

이후 참조에는 32 비트 또는 64 비트 (경우에도 nulll) 에 대한 데이터 관련 시스템, 나는 4 세트 들어 32 비트 및 64 비트 '링케들리츠' 와 '라일리츠'.

• • • 에 대한 '대한' 선은 Note:* 표시됩니까 크기가 라일리스트 트리밍한 열거합니다 - 실제로 용량을 초과하는 '한' 은 일반적으로 백킹을 어레이입니다 라일리스트 라우트의 현재 요소점 카운트입니다.

• 참고 2: * 으로 (기본적으로) 에서 지금 미드플레인 JDK6 클린업합니다 콤프레스도로프슈 (감사합니다 비론럽) 값은 기본적으로 32 비트 및 64 비트 시스템은 물론 네가 그 이하로 맞출 경우, 특히 최근 끕니다.

! 그래프를 링케드리스트 요소 및 라일리스트 노스 x 바이트입니다

그 결과 '는 훨씬 더 많은' 전체 '링케드리스트 여실히 보여주고 있는 라일리스트', 특히 매우 높은 요소점 카운트입니다. '회피' 의 경우 메모리는 팩터도 선택해제합니다 링케들리츠.

나는 내가 준수하십시오 공식을 사용하여, 나한테 다운로드되었는지 수행됨 내아기마저도 수리입니다 아무런 문제가 및 it up. b& # 39, & # 39. 32 비트 또는 64 비트 시스템, & # 39 는 4 또는 8 용 n& # 39;; 요소의 숫자입니다. 기록하십시오 mods 의 객체에는 java 는 시행하십시오 이유가 있기 때문에 모든 최고 8 바이트 공간 배수인지 여부와 상관 없이 모든 중고 방관하겠나.

• ArrayList:*

'정수 + + + + 어레이입니다 참조입니다 라일리스트 객체에는 헤더입니다 용량마다 모드카운트 정수 (어레이입니다 oject 헤더입니다 + b n) + 모드용 (어레이입니다 oject, 8) + + + + 4 = 8 모드용 (라일리스트 객체에는, 8) 4 + b (12 + b n) + 모드용 (12, 8 + b n) + 모드용 (8 + 4 + 4 + b + (12 + b n) + 모드용 (12 + b * n, 8), 8)'

• LinkedList:*

'링케드리스트 객체에는 헤더입니다 + 크기 정수 + 모드카운트 정수 + 참조입니다 머리글로 + 참조입니다 바닥글에 + (노드입니다 객체에는 오버헤드에 + 참조입니다 이전 요소점 + 참조입니다 다澜 요소점 + 참조입니다 요소) n) + 모드용 (노드입니다 객체에는, 8) n + 8 + 4 + 4 + 2가 모드용 (링케드리스트 객체에는, 8) = b + (8 + 3 b) n + 모드용 (8 + 3 b, 8) n + 모드용 (8 + 4 + 4 + 2가 b + (8 + 3 b) n + 모드용 (8 + 3 b, 8) n, 8)'

'는' 라일리스트 그리웠댔지. 거의 항상 (performance) '는' 링케드리스트 버그.

'왜' 링케드리스트 그것은됐다:

• It 프로세스 전반에 걸쳐 성능을 저하됨, 따라서 수많은 작은 메모리 오브젝트에도 사용합니다.
• 수많은 작은 개체는 캐시 집약성을 건강에 좋지.
• O (n) 는 이동, 즉 모든 인덱스된 작업이 필요한 성능. 이 알고리즘은 O (n) 의 소스 코드를 명백하네 없는 경우 '' 등 보다 느린 라일리스트 사용했다.
• 까다로운 좋은 성능을 얻을 수 있다. 아마도 ',' 라일리스트 동일합니까 때에도 큰 오 성능은 상당히 느린 것이 될 겁니다.
• It 's' 에서 볼 수 있기 때문에 소스를 링케드리스트 부조화, It& # 39 는 아마 잘못된 선택이다.

사람이 서피스로서 이래 약 십 년 동안, 웹 서비스 운영 성과를 엔지니어링용 on very large scale SOA 의 비헤이비어를 통해 꼭 이래야겠어요 포지셔닝하십시오 링케드리스트 라일리스트. 정상 상태 동안 이어질 수 있으므로 링케드리스트 처리량입니다 더 늘어나면 하드웨어 - 라일리스트 의 비헤이비어를 될 수 있는 앱을 압박을 받고 있는 클러스터와의 인근 synchronicity 및 대규모 어레이입니다 크기를 확대하고 어레이에는 될 수 있는 앱을 실행하고 있는 동안, 정전, 응답성의 부족이 심각한 압박을 받고 있는 비헤이비어를.

마찬가지로, app 에서 얻을 수 있으며, 그러나 일단 한번 더 나은 처리량의 기본값에서 처리량의 종신 쓰레기요 모음기 확보하십시오 jave 앱을 잠금식 up the wind up 10gb 힙 앱으로 25 초) 동안 수 있습니다. 이로 인해 soa 의 경우 full gc timeouts 및 장애 앱과 타격은 너회의 sla 를 너무 자주 발생합니다. 비록 많은 시간이 소요되는 CMS 모음기 리소스와자원과 언약보다는 같은 것이 훨씬 더 나은 선택을 이룹니까 기초형상 처리량의 가지고 있기 때문에 예측 가능하고 작은 지연.

라일리스트 의 경우 성능이 더 나은 선택을 한 것은 모든 그러니까 정도에 따라 처리량의 및 지연 무시할 수 있습니다. 내 경험상 dell. 내 일은 내가 무시할 수 없는 최악의 지연.

Algorithm           ArrayList   LinkedList
seek front            O(1)         O(1)
seek back             O(1)         O(1)
seek to index         O(1)         O(N)
insert at front       O(N)         O(1)
insert at back        O(1)         O(1)
insert after an item  O(N)         O(1)

[알고리즘: 빅 오 표기법] (http://leepoint.net/algorithms/big-oh/bigoh.html)

하지만 나쁜 dell. 추가/제거 라일리츠 유용합니다 worm (write-once-read-many) 또는 아펜더스 전면에서 또는 중간.

그래, 나도 알아, 이는 고대 질문을 던져 I& # 39, ll, 하지만 내 2 센트.

, 는 성능 위주 링케드리스트 거의 항상 잘못된 선택이다. 몇 가지 경우에 대해 매우, 매우 구체적인 알고리즘을 링케드리스트 호출됨 매우 드물며, 그러나 그 후 이 알고리즘을 특별히 취하면 LinkedList& # 39 에 의존하고 있는 요소를 삽입, 삭제, ve, 중간에 한 번 비교적 빨리 나열하십시오 you& # 39 한 좁히어 수신기마다 리스트리트레이터.

하나의 공통 览侩 荤례 좁히어 가 있는 링케드리스트 라일리스트 방문한다. 그 대기열은. 그러나 중요한 것은 성능입니까 링케드리스트 라이브록링크루 사용하는 대신 목표에 고려해야 합니다 (할 수 있는지 결정하는 쇱そ 바인딩되지 너회의 대기열은 할당하고자 감당할 수 있고, 모든 메모리 크기 미리 사전에) 또는 이 시르쿨라라이리스트 구축상의. (예, it& # 39 의 2001년, 그래서 you& # 39, ll 할 진리피 아니지만, 나는 attaboy 비슷한 성능을 제거율 를 what& 이제 막 말을 인용, s # 39 이 글에서 최근 JVM)

39 의 it& 질문이예요 efficiency; '빠른' 는 특정 요소를 추가하거나 삭제할 수 있지만, 느린 링케드리스트 액세스하려면 요소. 하지만 특정 요소 '가 빠른 속도가 느려질 수 있습니다' 라일리스트 액세스하면 추가할 수 있는 가운데, 특히 느린 삭제하시겠습니까 한쪽 끝.

어레이입니다 vs 라일리스트 vs 링케드리스트 vs 벡터입니다) 에 더 깊이 때처럼 댁이라면 링크드 리스트.

올바른 또는 잘못된: 실행하십시오 테스트 및 로컬으로 결정할 교도관님도요!

'에서' 보다 '' 라일리스트 링케드리스트 edit/remove 더 빠릅니다.

'', ',' 어레이입니다 라일리스트 뒷받침됩니다 크기, 더 큰 볼륨입니다 연산뿐 하는 프로그램.

다음은 각 단위 테스트 결과, 운영할 수 있다. 주어진 시기는 나노초.

Operation                       ArrayList                      LinkedList  

AddAll   (Insert)               101,16719                      2623,29291 

Add      (Insert-Sequentially)  152,46840                      966,62216

Add      (insert-randomly)      36527                          29193

remove   (Delete)               20,56,9095                     20,45,4904

contains (Search)               186,15,704                     189,64,981

39 의 here& 코드:

import org.junit.Assert;
import org.junit.Test;

import java.util.*;

public class ArrayListVsLinkedList {
    private static final int MAX = 500000;
    String[] strings = maxArray();

    ////////////// ADD ALL ////////////////////////////////////////
    @Test
    public void arrayListAddAll() {
        Watch watch = new Watch();
        List stringList = Arrays.asList(strings);
        List arrayList = new ArrayList(MAX);

        watch.start();
        arrayList.addAll(stringList);
        watch.totalTime("Array List addAll() = ");//101,16719 Nanoseconds
    }

    @Test
    public void linkedListAddAll() throws Exception {
        Watch watch = new Watch();
        List stringList = Arrays.asList(strings);

        watch.start();
        List linkedList = new LinkedList();
        linkedList.addAll(stringList);
        watch.totalTime("Linked List addAll() = ");  //2623,29291 Nanoseconds
    }

    //Note: ArrayList is 26 time faster here than LinkedList for addAll()

    ///////////////// INSERT /////////////////////////////////////////////
    @Test
    public void arrayListAdd() {
        Watch watch = new Watch();
        List arrayList = new ArrayList(MAX);

        watch.start();
        for (String string : strings)
            arrayList.add(string);
        watch.totalTime("Array List add() = ");//152,46840 Nanoseconds
    }

    @Test
    public void linkedListAdd() {
        Watch watch = new Watch();

        List linkedList = new LinkedList();
        watch.start();
        for (String string : strings)
            linkedList.add(string);
        watch.totalTime("Linked List add() = ");  //966,62216 Nanoseconds
    }

    //Note: ArrayList is 9 times faster than LinkedList for add sequentially

    /////////////////// INSERT IN BETWEEN ///////////////////////////////////////

    @Test
    public void arrayListInsertOne() {
        Watch watch = new Watch();
        List stringList = Arrays.asList(strings);
        List arrayList = new ArrayList(MAX + MAX / 10);
        arrayList.addAll(stringList);

        String insertString0 = getString(true, MAX / 2 + 10);
        String insertString1 = getString(true, MAX / 2 + 20);
        String insertString2 = getString(true, MAX / 2 + 30);
        String insertString3 = getString(true, MAX / 2 + 40);

        watch.start();

        arrayList.add(insertString0);
        arrayList.add(insertString1);
        arrayList.add(insertString2);
        arrayList.add(insertString3);

        watch.totalTime("Array List add() = ");//36527
    }

    @Test
    public void linkedListInsertOne() {
        Watch watch = new Watch();
        List stringList = Arrays.asList(strings);
        List linkedList = new LinkedList();
        linkedList.addAll(stringList);

        String insertString0 = getString(true, MAX / 2 + 10);
        String insertString1 = getString(true, MAX / 2 + 20);
        String insertString2 = getString(true, MAX / 2 + 30);
        String insertString3 = getString(true, MAX / 2 + 40);

        watch.start();

        linkedList.add(insertString0);
        linkedList.add(insertString1);
        linkedList.add(insertString2);
        linkedList.add(insertString3);

        watch.totalTime("Linked List add = ");//29193
    }

    //Note: LinkedList is 3000 nanosecond faster than ArrayList for insert randomly.

    ////////////////// DELETE //////////////////////////////////////////////////////
    @Test
    public void arrayListRemove() throws Exception {
        Watch watch = new Watch();
        List stringList = Arrays.asList(strings);
        List arrayList = new ArrayList(MAX);

        arrayList.addAll(stringList);
        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        arrayList.remove(searchString0);
        arrayList.remove(searchString1);
        watch.totalTime("Array List remove() = ");//20,56,9095 Nanoseconds
    }

    @Test
    public void linkedListRemove() throws Exception {
        Watch watch = new Watch();
        List linkedList = new LinkedList();
        linkedList.addAll(Arrays.asList(strings));

        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        linkedList.remove(searchString0);
        linkedList.remove(searchString1);
        watch.totalTime("Linked List remove = ");//20,45,4904 Nanoseconds
    }

    //Note: LinkedList is 10 millisecond faster than ArrayList while removing item.

    ///////////////////// SEARCH ///////////////////////////////////////////
    @Test
    public void arrayListSearch() throws Exception {
        Watch watch = new Watch();
        List stringList = Arrays.asList(strings);
        List arrayList = new ArrayList(MAX);

        arrayList.addAll(stringList);
        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        arrayList.contains(searchString0);
        arrayList.contains(searchString1);
        watch.totalTime("Array List addAll() time = ");//186,15,704
    }

    @Test
    public void linkedListSearch() throws Exception {
        Watch watch = new Watch();
        List linkedList = new LinkedList();
        linkedList.addAll(Arrays.asList(strings));

        String searchString0 = getString(true, MAX / 2 + 10);
        String searchString1 = getString(true, MAX / 2 + 20);

        watch.start();
        linkedList.contains(searchString0);
        linkedList.contains(searchString1);
        watch.totalTime("Linked List addAll() time = ");//189,64,981
    }

    //Note: Linked List is 500 Milliseconds faster than ArrayList

    class Watch {
        private long startTime;
        private long endTime;

        public void start() {
            startTime = System.nanoTime();
        }

        private void stop() {
            endTime = System.nanoTime();
        }

        public void totalTime(String s) {
            stop();
            System.out.println(s + (endTime - startTime));
        }
    }

    private String[] maxArray() {
        String[] strings = new String[MAX];
        Boolean result = Boolean.TRUE;
        for (int i = 0; i < MAX; i++) {
            strings[i] = getString(result, i);
            result = !result;
        }
        return strings;
    }

    private String getString(Boolean result, int i) {
        return String.valueOf(result) + i + String.valueOf(!result);
    }
}

'라일리스트' 본질적으로 어레이입니다. '구현되고 링케드리스트' 더블 링크드 리스트.

이 '수' 는 확실합니다. O (1) 을 사용하여 '때문에', '랜덤 액세스 허용' 라일리스트 라일리스트 색인입니다. O (n) 을 찾기 위해 필요가 있기 때문에 ',' 링케드리스트 인덱스화할 이번이 처음이다. 참고: 여러 가지 버전의 '추가' 와 '제거'.

하지만 느린 속도를 추가하고 제거할 수 있는 '는' 링케드리스트. 간단히 말해, '기본' 링케드리스트 경우 합니다.

많은 수의 임의적입니까 액세스하도록 요소가 없는 1. 많은 경우 추가 / 제거 작업을 2.

• = 라일리스트 = *

• 추가 (E e)

• 추가 라일리스트 말
• 메모리 크기조절하기 필요한 비용.
• O (n), 최악의 상각 O (1)

• 추가 (int index ᄆ씨 요소)

• 특정 인덱스화할 추가합니까 포지셔닝하십시오
• &amp 등이 필요합니다. 가능한 메모리 크기조정 비용
• O (n)

• 제거 (int index)

• 지정된 요소 제거
• &amp 등이 필요합니다. 가능한 메모리 크기조정 비용
• O (n)

• 분리하십시오 (Object o)

• 처음에는 이 목록에서 지정한 요소 제거 첫째, 그리고 변화하는 &amp 검색하시겠습니까 할 요소 -; 가능한 메모리 크기조정 비용
• O (n)

• = 링케드리스트 = *

• 추가 (E e)

• the end of the 추가합니까 목록
• O (1)

• 추가 (int index ᄆ씨 요소)

• 지정된 점에서 삽입하십시오 포지셔닝하십시오
• 첫 번째 위치를 찾아야
• O (n)

• 제거 ()

• 목록의 첫 번째 요소 제거
• O (1)

• 제거 (int index)

• 요소 제거, 지정된 인덱스화할
• 먼저 찾아야 할 요소
• O (n)

• 분리하십시오 (Object o)

• 첫 번째 항목으로 분리하십시오 지정된 요소의
• 먼저 찾아야 할 요소
• O (n)

다음은 인사가 programcreek.com ('추가' 와 '제거' 이 첫 번째 유형, 즉, 요소를 추가하는 끝에 지정된 위치에 있는 요소 목록 및 분리하십시오 명단요):

enter 이미지 여기에 설명을!

조슈아 블로흐, 저자의 링케드리스트:

&gt. 실제로 사용하는 링케드리스트 누구? 내가 작성했습니까 정보기술 (it), 나는치료가그렇게 사용한다.

링크: https://twitter.com/joshbloch/status/583813919019573248

39 m 로, 이 문제에 대한 것이 아니라 이런 i& 기술입니까 담겨 있지만, 다른 답을 줄 알았는데 약간만이라도 가장 흥미로운 및 자명하다.

한편, 라일리스트 임의로 접근할 수 있는 '는' 진짜 '링케드리스트 확장하여 분리하십시오 싼' 중에서. 대부분의 경우, 라일리스트 '' 정상입니다.

39, ve 창조하 열거합니다 you& 않으면 큰 걱정할 필요가 없는 # 39, ll, 무게, 아마도 you& 병목 현상을 말한다.

이 경우 추가 (0) '와' 제거 '코드', ' (0)' 와 '# 39 을 사용하여 링케드리스트 it& 이쁘게 아다퍼스트 ()' 와 '레모베퍼스트 ()' 방법입니다. 그렇지 않으면 '' 라일리스트 사용합니다.

물론, & # 39 의 구아바, 이무터블리스트 는 자신의 베스트프렌드야.

하지만 난 # 39 이것은 오래된 그러니까말이야 게시물로의 링케드리스트 't believe that' 은 '데크, 장난하는거아니고 can& 아니예 언급한'. 그냥 보는 방법으로 '데크' (및 '큐'); 스케쳐내 링케드리스트 라데크 '과' 공정한 비교, 실행하십시오 상대로 하는 '' 기능에 대한-기능 비교.

• TL; DR * 인해 '현대' 을 위한 훨씬 더 효율적인 활용 가능한 거의 모든 컴퓨터 아키텍처, 라일리스트 링케드리스트 일부 극단적 사례를 제외하고는 매우 고유해야 하고, 따라서 '-' 피해야 합니다.

이론적으로 링케드리스트 O (1) '에 대한 추가 (E 요소점)'

또한 미드플레인 목록 추가 요소가 더 효율적일 것이다.

방법은 매우 다른 등 적대적 캐시에는 링케드리스트 는 데이터 구조. '에서' 더 나은 성능을 수행하는 경우가 거의 가지 관점 - '보다' 캐시 친화적임 라일리스트 링케드리스트 될 수 있다.

다음은 벤치마크입니다 테스트 결과 임의 요소 삽입 위치. 이 어레이에는 목록을 볼 수 있듯이, 이론적으로는 삽입하십시오 더욱 효율적으로 경우 각 목록의 가운데에서, move&quot &quot 필요합니다. n 나중에 이 요소를 배열 (값이 낮을수록 더):

! [입력하십시오. 이미지 여기에 설명을] [1]

나중에 working on a 세대 하드웨어 (더 큰, 보다 효율적인 캐시합니다) - 결과는 더욱 결정적인:

! [입력하십시오. 이미지 여기에 설명을] [2]

같은 작업을 수행하기 위해 더 많은 시간을 링케드리스트 걸립니다. [출처] (https://kjellkod.wordpress.com/2012/08/08/java-galore-linkedlist-vs-arraylist-vs-dynamicintarray/) [소스코드] (https://ideone.com/JOJ05)

이 두 가지 주요 원인.

• • • 주로 작업자쪽에서 노드입니다 링케드리스트 '의 1.' 메모리 통해 무작위로 흩어져 살고 있다. RAM (Random Access Memory&quot ";) # 39, t really isn& 무순서 및 메모리 블록을 할 반입됨 캐시하려면. 이 작업은 시간이 걸리고, 언제 패치합니다 자주 발생하는 등 모든 시간 - - 메모리 페이지를 캐시에 &gt 교체해야 한다. 캐시 실패 - &gt. 캐시는 효율적이지 않습니다. '요소' 라일리스트 저장되어 있는 현대 CPU 아키텍처는 .용 최적화합니다 정확히 횡단면도 메모리 -
• • '링케드리스트 유지하는 데 필요한 보조 2.', 즉 뒤로를 / 앞으로 포인터 값을 메모리에 저장된 소비량은 비해 3 배 '라일리스트'.

[디나미킨타이] (https://github.com/apache/orc/blob/master/java/core/src/java/org/apache/orc/impl/DynamicIntArray.java) 는 Int ' (primitive type) 과' 맞춤형 라일리스트 구축현 브트와 개최 - 업그레이드됨 객체가 아닌 모든 데이터가 정말 저장됩니까 인접하게 - 업그레이드됨 더욱 효과적으로 수행할 수 있습니다.

핵심 요소를 가져오는 것은 상당한 비용이 더 이상 메모리 블록을 너희에게베풀어진 비용을 액세스을 하나의 메모리 셀. # 39 의 메모리는 1MB 의 순차인지 that& 왜 판독기에서 최대 x400 배나 빠른 속도로 판독값 이 양의 데이터를 서로 다른 메모리 블록을.

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD
Read 1 MB sequentially from memory     250,000   ns      250 us
Round trip within same datacenter      500,000   ns      500 us
Read 1 MB sequentially from SSD*     1,000,000   ns    1,000 us    1 ms  ~1GB/sec SSD, 4X memory
Disk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtrip
Read 1 MB sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20X SSD
Send packet CA->Netherlands->CA    150,000,000   ns  150,000 us  150 ms

출처: [지연 시간 수치를 알아야 할 모든 프로그래머용] (https://gist.github.com/jboner/2841832)

그냥 더 추가할 수 있도록 요점이지 fopen 시작 부분에 요소를 명단요 벤치마트 확인하십시오. 이 이론에 의하면, 여기서 '및' 샤인 '이 링케드리스트 활용, 라일리스트 χ02 케이블링의 심지어 최악의 경우' 결과 받아야 할 것이다.

! [입력하십시오. 이미지 여기에 설명을] [3]

참고: 이것은 C++ 표준 라이브러리, 하지만 내 이전 경험에 대한 벤치마크입니다 C++, 자바 결과가 나와 매우 비슷하다. [소스코드] (https://ideone.com/DDEJF)

메모리 최적화 작업을 통해 현대의 cpu 는 복사 불크 순차인지 변경 - 이론과 실제 '/' 벡터 ',' 다시 만들기, 라일리스트 훨씬 더 효율적인

크레딧. 여기서 모든 벤치마크 게시하기를 의해 생성되는 [셸 Hedstr& # 246, m] (https://www.linkedin.com/in/kjellkod/). 더 많은 데이터가 [자신의 블로그] 에서 찾을 수 있습니다 (https://kjellkod.wordpress.com/)

다음은 모두에서 큰 오 표기법 또한 CopyOnWrite-ArrayList 링케드리스트 '와' 라일리스트 '와' '':

• 라일리스트 *

get                 O(1)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

• 링케드리스트 *

get                 O(n)
add                 O(1)
contains            O(n)
next                O(1)
remove              O(1)
iterator.remove     O(1)

• CopyOnWrite-ArrayList *

get                 O(1)
add                 O(n)
contains            O(n)
next                O(1)
remove              O(n)
iterator.remove     O(n)

이를 근거로 결정할 선택할 수 있습니다. )

39 의 비교 및 라일리스트 w.r.t. 링케드리스트 let& 아래 매개변수입니다:

1. # 구축상의

&gt. , 는 크기변경가능 (s) 시스템 구축을 동시에 인터페이스입니다 라일리스트 목록 &gt. &gt. 는 두 링크됨 링케드리스트 구축현 나열하십시오 목록의 인터페이스입니다.

• 2. # 성능

• &lt h3&gt 프레젠테이션이든 (int index) 또는 검색 operation&lt /h3>;;;

&gt. 라일리스트 프레젠테이션이든 (int index) 에서 실행되는 동안 작업을 이리에 상수입니다 시간 O (1) &gt. &gt. 링케드리스트 프레젠테이션이든 (int index) 는 작업 실행 시간 O (n).

그 이유는 라일리스트 견하여 기술입니까 링케드리스트 라일리스트 등에 대한 기반 시스템을 사용하는 것이 보다 인덱스화할 대로 요소를 배열 내부적으로 사용하는 반면,

• • 제공하지 않기 때문에 인컨텍스트 링케드리스트 인덱스 기반 접근할 수 있도록 해당 요소를 가져온 처음부터 단면이거나 끝 (둘 중 가까울수록) 읽어들이려면 노드입니다 dell. 지정된 요소점 색인입니다.

• &lt h3&gt 삽입하십시오 () 또는 추가 (객체) operation&lt /h3>;;;

&gt. 비교할 때 빠르게 일반적으로 삽입 in 링케드리스트 라일리스트. O (1) 의 추가 또는 삽입이 링케드리스트 운영할 수 있다. &gt. &gt. , 는 최악의 경우 전체 이리에 어레이입니다 라일리스트 있는 동안, 추가 비용 문제가 발생할 수 있는 새로운 어레이입니다 크기조정 어레이입니다 및 복사 요소 중 런타임용으로 개발하십시오 라일리스트 의 O (n) 의 추가 작업을 그렇지 않으면 O (1).

• &lt (int);;; h3&gt 제거하시겠습니까 operation&lt /h3&gt.

일반적으로 제거 작업을 링케드리스트 동일합니까 라일리스트 즉 O (n).

&gt. , 링케드리스트 과부하된 분리하십시오 있는 두 가지 방법. 하나는 제거 () 의 수장 없이 매개변수입니다 절감뿐만 상수입니다 시간 O (1) 등을 운영하고 있는 목록. 다른 방법으로 과부하된 분리하십시오 링케드리스트 (int) 또는 제거 (객체) 또는 int 는 분리하십시오 절감뿐만 객체에는 있는 지 비호환성의 매개변수입니다. 이 방법을 찾을 때까지 이 링케드리스트 트래버스합니다 객체 및 정보기술 (it) 는 원래 연결해제 목록. 이 방법을 업그레이드됨 런타임용으로 개발하십시오 는 O (n). &gt. &gt. 제거 (int) 메서드로부터 部门从 복사 요소 중 라일리스트 를 이전 스토리지로는 런타임용으로 개발하십시오 O (n) 는 새로운 업데이트되도록 업그레이드됨 어레이이며 있다.

3. # 역동기화 반복자가

&gt. 이터레이션된 링케드리스트 역뱡향으로 방향선이 데상드린기트레이터 동시에 사용할 수 있습니다 () &gt. &gt. , 라일리스트 데상드린기트레이터 없다 () 에 있는 우리 자신의 코드를 작성할 필요가 있어 그 반대 방향으로 라일리스트 를 반복할.

4. 초기 용량을

&gt. Tcpg 있지 않은 경우 구성자를 과부하된 관심용 라일리스트 빈 목록니다 초기 용량을 동시에 10 &gt. &gt. 전용 구문 링케드리스트 초기 용량을 없이 빈 목록.

5. 메모리 오버헤드

&gt. 링케드리스트 오버헤드에 라일리스트 의 메모리) 에 비해 훨씬 많은 것처럼 링케드리스트 노드입니다) 의 주소를 유지해야 합니다 다음 및 이전 노드입니다. 동시에 &gt. &gt. 라일리스트 의 각 색인에만 실제 객체 (데이터) 를 보유하고 있다.

출처

난 보통 다른 이름을 사용할 수 있는 시간을 기준으로 놓고 복잡한 작업을 수행할 수 있는 I&; d # 39 의 특정 목록.

|---------------------|---------------------|--------------------|------------|
|      Operation      |     ArrayList       |     LinkedList     |   Winner   |
|---------------------|---------------------|--------------------|------------|
|     get(index)      |       O(1)          |         O(n)       | ArrayList  |
|                     |                     |  n/4 steps in avg  |            |
|---------------------|---------------------|--------------------|------------|
|      add(E)         |       O(1)          |         O(1)       | LinkedList |
|                     |---------------------|--------------------|            |
|                     | O(n) in worst case  |                    |            |
|---------------------|---------------------|--------------------|------------|
|    add(index, E)    |       O(n)          |         O(n)       | LinkedList |
|                     |     n/2 steps       |      n/4 steps     |            |
|                     |---------------------|--------------------|            |
|                     |                     |  O(1) if index = 0 |            |
|---------------------|---------------------|--------------------|------------|
|  remove(index, E)   |       O(n)          |         O(n)       | LinkedList |
|                     |---------------------|--------------------|            |
|                     |     n/2 steps       |      n/4 steps     |            |
|---------------------|---------------------|--------------------|------------|
|  Iterator.remove()  |       O(n)          |         O(1)       | LinkedList |
|  ListIterator.add() |                     |                    |            |
|---------------------|---------------------|--------------------|------------|

|--------------------------------------|-----------------------------------|
|              ArrayList               |            LinkedList             |
|--------------------------------------|-----------------------------------|
|     Allows fast read access          |   Retrieving element takes O(n)   |
|--------------------------------------|-----------------------------------|
|   Adding an element require shifting | o(1) [but traversing takes time]  |
|       all the later elements         |                                   |
|--------------------------------------|-----------------------------------|
|   To add more elements than capacity |
|    new array need to be allocated    |
|--------------------------------------|

또 다른 좋은 '는', '위' 라일리스트 디이브이 인수만 합니다 '는' 큐 '' 링케드리스트 란도메클레스 인터페이스입니다 동시에.

그래서 그들은 약간 다른 문제를 해결할 수 있는 효율성과 비헤이비어를 차이, 짐작이지만요. (그들의 메서드을 목록 참조).

작업에 대한 더 많은 일을 할 때 달려 명단요

'한' 가 더 빠르게 라일리스트 액세스하려면 인덱스된 값입니다. 이 때 훨씬 더 삽입 또는 객체 삭제.

자세한 내용을 읽을 수 있는 모든 문서, 차이점은 어레이에는 및 링크됨 이야기하고 있습니다.

참조 Java 자습서는 - 목록을 구현.