'링케드리스트' 와 '라일리스트 구축' 는 서로 다른 두 나열하십시오 인터페이스입니다. it with a '는' 링케드리스트 두 링크됨 목록. 라일리스트 '는' 으로 다시 크기 조정 무중단으로 어레이입니다.
표준 연결 리스트 마찬가지로 여러 가지 방법 및 어레이입니다 운영체, 알고리즘 런타임을 다를 수 있습니다.
<, sup>, 참고: 상수입니다 n/4 단계를 하는 작업 중 많은 수가 평균 최상 단계는 n/2 단계에 있으며, (예를 들면 인덱스화할 = 0) (최악인 가운데 목록) < /sup>;
2 의 [E> ArrayList<, ',']
<, sup>, 참고: , N/2 단계를 하는 작업 중 많은 수가 평균 상수입니다 , n 단계를 최상 단계는 (end of 목록) 최악의 경우 (시작 목록) < /sup>;
, 반복자를 사용하는 ',' LinkedList< E> 순차식 액세스하도록 아니라, 일정 시간 삽입 또는 제거 가능 요소. 즉, 당신이 찾는 목록에서 앞뒤로 목록에 걸을 수 있지만, 포지셔닝하십시오 크기에 비례하는 시간이 명단요 말하고 있는 javadoc " 꽂으십시오 목록으로, 작업을 처음부터 끝까지 인덱스화할 트래버스할 목록 중 현재 closer", 그러니까 그 방법을 모두 , 또는 O (n), 평균적으로 O (1) ( n/4 단계) = 0 '의' 인덱스화할 표시되어도.
반면, ',' ArrayList< E> 읽을 수 있도록 빠른 랜덤 액세스 할 수 있는 시스템을 모든 요소에 상수입니다 하게하면서요. 그러나 변화하는 모든 요소를 추가하거나 제거할 수 있지만 어디서부터든 및끝 单捞磐啊 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 는 메모리 공간 외에 각 않는다는 데 의견을 모으고 있는 ',' 는 이러한 열거합니다 일반 링케드리스트 " 많이 more". 그래서 내가 얼마나 정확히 입증할 수 있는 '라일리스트 비해 몇 가지 수치 연산 모두 자신만을 위해 시행하십시오 열거합니다 ᄂ씨 nulll 참조입니다.
이후 참조에는 32 비트 또는 64 비트 (경우에도 nulll) 에 대한 데이터 관련 시스템, 나는 4 세트 들어 32 비트 및 64 비트 '링케들리츠' 와 '라일리츠'.
참고 2: * 으로 (기본적으로) 에서 지금 미드플레인 JDK6 클린업합니다 콤프레스도로프슈 (감사합니다 비론럽) 값은 기본적으로 32 비트 및 64 비트 시스템은 물론 네가 그 이하로 맞출 경우, 특히 최근 끕니다.
! 그래프를 링케드리스트 요소 및 라일리스트 노스 x 바이트입니다
그 결과 '는 훨씬 더 많은' 전체 '링케드리스트 여실히 보여주고 있는 라일리스트', 특히 매우 높은 요소점 카운트입니다. '회피' 의 경우 메모리는 팩터도 선택해제합니다 링케들리츠.
나는 내가 준수하십시오 공식을 사용하여, 나한테 다운로드되었는지 수행됨 내아기마저도 수리입니다 아무런 문제가 및 it up. b& # 39, & # 39. 32 비트 또는 64 비트 시스템, & # 39 는 4 또는 8 용 n& # 39;; 요소의 숫자입니다. 기록하십시오 mods 의 객체에는 java 는 시행하십시오 이유가 있기 때문에 모든 최고 8 바이트 공간 배수인지 여부와 상관 없이 모든 중고 방관하겠나.
'정수 + + + + 어레이입니다 참조입니다 라일리스트 객체에는 헤더입니다 용량마다 모드카운트 정수 (어레이입니다 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)'
'링케드리스트 객체에는 헤더입니다 + 크기 정수 + 모드카운트 정수 + 참조입니다 머리글로 + 참조입니다 바닥글에 + (노드입니다 객체에는 오버헤드에 + 참조입니다 이전 요소점 + 참조입니다 다澜 요소점 + 참조입니다 요소) 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) '는' 링케드리스트 버그.
'왜' 링케드리스트 그것은됐다:
사람이 서피스로서 이래 약 십 년 동안, 웹 서비스 운영 성과를 엔지니어링용 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)
올바른 또는 잘못된: 실행하십시오 테스트 및 로컬으로 결정할 교도관님도요!
'에서' 보다 '' 라일리스트 링케드리스트 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
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<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(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<String> stringList = Arrays.asList(strings);
watch.start();
List<String> linkedList = new LinkedList<String>();
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<String> arrayList = new ArrayList<String>(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<String> linkedList = new LinkedList<String>();
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<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(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<String> stringList = Arrays.asList(strings);
List<String> linkedList = new LinkedList<String>();
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<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(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<String> linkedList = new LinkedList<String>();
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<String> stringList = Arrays.asList(strings);
List<String> arrayList = new ArrayList<String>(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<String> linkedList = new LinkedList<String>();
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)
= 링케드리스트 = *
추가 (E e)
다음은 인사가 programcreek.com ('추가' 와 '제거' 이 첫 번째 유형, 즉, 요소를 추가하는 끝에 지정된 위치에 있는 요소 목록 및 분리하십시오 명단요):
이론적으로 링케드리스트 O (1) '에 대한 추가 (E 요소점)'
또한 미드플레인 목록 추가 요소가 더 효율적일 것이다.
방법은 매우 다른 등 적대적 캐시에는 링케드리스트 는 데이터 구조. '에서' 더 나은 성능을 수행하는 경우가 거의 가지 관점 - '보다' 캐시 친화적임 라일리스트 링케드리스트 될 수 있다.
다음은 벤치마크입니다 테스트 결과 임의 요소 삽입 위치. 이 어레이에는 목록을 볼 수 있듯이, 이론적으로는 삽입하십시오 더욱 효율적으로 경우 각 목록의 가운데에서, move" " 필요합니다. n 나중에 이 요소를 배열 (값이 낮을수록 더):
나중에 working on a 세대 하드웨어 (더 큰, 보다 효율적인 캐시합니다) - 결과는 더욱 결정적인:
같은 작업을 수행하기 위해 더 많은 시간을 링케드리스트 걸립니다. [출처] (https://kjellkod.wordpress.com/2012/08/08/java-galore-linkedlist-vs-arraylist-vs-dynamicintarray/) [소스코드] (https://ideone.com/JOJ05)
이 두 가지 주요 원인.
[디나미킨타이] (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 케이블링의 심지어 최악의 경우' 결과 받아야 할 것이다.
참고: 이것은 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)
get O(1)
add O(n)
contains O(n)
next O(1)
remove O(n)
iterator.remove O(n)
이를 근거로 결정할 선택할 수 있습니다. )
>. , 는 크기변경가능 (s) 시스템 구축을 동시에 인터페이스입니다 라일리스트 목록 >. >. 는 두 링크됨 링케드리스트 구축현 나열하십시오 목록의 인터페이스입니다.
< h3> 프레젠테이션이든 (int index) 또는 검색 operation< /h3>;;;
>. 라일리스트 프레젠테이션이든 (int index) 에서 실행되는 동안 작업을 이리에 상수입니다 시간 O (1) >. >. 링케드리스트 프레젠테이션이든 (int index) 는 작업 실행 시간 O (n).
그 이유는 라일리스트 견하여 기술입니까 링케드리스트 라일리스트 등에 대한 기반 시스템을 사용하는 것이 보다 인덱스화할 대로 요소를 배열 내부적으로 사용하는 반면,
>. 비교할 때 빠르게 일반적으로 삽입 in 링케드리스트 라일리스트. O (1) 의 추가 또는 삽입이 링케드리스트 운영할 수 있다. >. >. , 는 최악의 경우 전체 이리에 어레이입니다 라일리스트 있는 동안, 추가 비용 문제가 발생할 수 있는 새로운 어레이입니다 크기조정 어레이입니다 및 복사 요소 중 런타임용으로 개발하십시오 라일리스트 의 O (n) 의 추가 작업을 그렇지 않으면 O (1).
일반적으로 제거 작업을 링케드리스트 동일합니까 라일리스트 즉 O (n).
>. , 링케드리스트 과부하된 분리하십시오 있는 두 가지 방법. 하나는 제거 () 의 수장 없이 매개변수입니다 절감뿐만 상수입니다 시간 O (1) 등을 운영하고 있는 목록. 다른 방법으로 과부하된 분리하십시오 링케드리스트 (int) 또는 제거 (객체) 또는 int 는 분리하십시오 절감뿐만 객체에는 있는 지 비호환성의 매개변수입니다. 이 방법을 찾을 때까지 이 링케드리스트 트래버스합니다 객체 및 정보기술 (it) 는 원래 연결해제 목록. 이 방법을 업그레이드됨 런타임용으로 개발하십시오 는 O (n). >. >. 제거 (int) 메서드로부터 部门从 복사 요소 중 라일리스트 를 이전 스토리지로는 런타임용으로 개발하십시오 O (n) 는 새로운 업데이트되도록 업그레이드됨 어레이이며 있다.
>. 이터레이션된 링케드리스트 역뱡향으로 방향선이 데상드린기트레이터 동시에 사용할 수 있습니다 () >. >. , 라일리스트 데상드린기트레이터 없다 () 에 있는 우리 자신의 코드를 작성할 필요가 있어 그 반대 방향으로 라일리스트 를 반복할.
>. Tcpg 있지 않은 경우 구성자를 과부하된 관심용 라일리스트 빈 목록니다 초기 용량을 동시에 10 >. >. 전용 구문 링케드리스트 초기 용량을 없이 빈 목록.
>. 링케드리스트 오버헤드에 라일리스트 의 메모리) 에 비해 훨씬 많은 것처럼 링케드리스트 노드입니다) 의 주소를 유지해야 합니다 다음 및 이전 노드입니다. 동시에 >. >. 라일리스트 의 각 색인에만 실제 객체 (데이터) 를 보유하고 있다.
난 보통 다른 이름을 사용할 수 있는 시간을 기준으로 놓고 복잡한 작업을 수행할 수 있는 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 |
|--------------------------------------|