数组列表vs链表:为什么删除链表中的第一个元素比删除数组列表中的最后一个元素要快?

yzuktlbb  于 2021-06-30  发布在  Java
关注(0)|答案(1)|浏览(848)

这个问题在这里已经有答案了

如何用java编写正确的微基准测试(11个答案)
上个月关门了。
从数组列表的末尾删除项的时间复杂度为o(1),就像从链表的开头删除项一样。但是当我用java测试链表时,它还是快了一点,我不明白为什么。有人能解释为什么链表在时间复杂度为o(1)的情况下仍然更快吗?
换句话说,为什么从链表中删除第一个元素比从数组列表中删除最后一个元素要快?
我不认为我的代码能帮你回答我的问题,因为它更多的是关于数据结构的。但这里只是以防万一(不要介意法语,它是用来做作业的):

  1. LinkedList<Integer> LinkL = new LinkedList<Integer>();
  2. ArrayList<Integer> ArrL = new ArrayList<Integer>();
  3. int N;
  4. N = 1000;
  5. //2.creer le Linked List
  6. for(int i=0; i<N; i++) {
  7. LinkL.add(i);
  8. }
  9. //System.out.println(LinkL);
  10. //3. et 4.Supprimer les elements de Linked List et afficher le temps
  11. long debut = System.nanoTime();
  12. for(int i=0; i<N; i++) {
  13. LinkL.removeFirst();
  14. }
  15. long fin = System.nanoTime();
  16. long tempsExecution = fin - debut;
  17. System.out.println("1.Suppression des éléments de LinkL avec la méthode \nremoveFirst( ) de LinkedList, avec une durée \nduréeLinkedList = "+tempsExecution+ " nanosecondes"); //-
  18. //5.Creer Array List
  19. for(int i=0; i<N; i++) {
  20. ArrL.add(i);
  21. }
  22. //System.out.println(ArrL);
  23. //6.Supprimer les elements de Array List et afficher le temps
  24. debut = System.nanoTime();
  25. for(int i=0; i<N; i++) {
  26. ArrL.remove(0);
  27. }
  28. fin = System.nanoTime();
  29. tempsExecution = fin - debut;
  30. System.out.println("\n2.Suppression des éléments de ArrL avec remove(0) d’un \nArrayList, durée duréeArrayDirect = "+tempsExecution+ " nanosecondes");
  31. //7. Recreer ArrL
  32. for(int i=0; i<N; i++) {
  33. ArrL.add(i);
  34. }
  35. //System.out.println(ArrL);
  36. //Supprimer les elements de ArrL
  37. debut = System.nanoTime();
  38. for(int i=N-1; i>=0; i--) {
  39. ArrL.remove(i);
  40. }
  41. fin = System.nanoTime();
  42. tempsExecution = fin - debut;
  43. System.out.println("\n3.Suppression des éléments de ArrL avec remove(i) ciblant \nles derniers éléments d’un ArrayList, avec une durée \nde duréeArrayInverse = "+tempsExecution+ " nanosecondes");
  44. }
  45. }

提前谢谢。

vof42yt1

vof42yt11#

要了解原因,您必须查看代码源代码,看看在那里做了什么
数组表

  1. public E remove(int index) {
  2. rangeCheck(index);
  3. modCount++;
  4. E oldValue = elementData(index);
  5. int numMoved = size - index - 1;
  6. if (numMoved > 0)
  7. System.arraycopy(elementData, index+1, elementData, index,
  8. numMoved);
  9. elementData[--size] = null; // clear to let GC do its work
  10. return oldValue;
  11. }

双链表

  1. public E remove(int index) {
  2. checkElementIndex(index);
  3. return unlink(node(index));
  4. }
  5. Node<E> node(int index) {
  6. // assert isElementIndex(index);
  7. if (index < (size >> 1)) {
  8. Node<E> x = first;
  9. for (int i = 0; i < index; i++)
  10. x = x.next;
  11. return x;
  12. } else {
  13. Node<E> x = last;
  14. for (int i = size - 1; i > index; i--)
  15. x = x.prev;
  16. return x;
  17. }
  18. }
  19. public boolean remove(Object o) {
  20. if (o == null) {
  21. for (Node<E> x = first; x != null; x = x.next) {
  22. if (x.item == null) {
  23. unlink(x);
  24. return true;
  25. }
  26. }
  27. } else {
  28. for (Node<E> x = first; x != null; x = x.next) {
  29. if (o.equals(x.item)) {
  30. unlink(x);
  31. return true;
  32. }
  33. }
  34. }
  35. return false;
  36. }

如果从arraylist中删除一个元素,则该元素之后的元素应该向左移动,这一操作需要时间。另一方面,如果从linkedlist中删除元素,首先我们应该找到元素(此操作的速度,取决于列表大小),然后通过从列表中取消限制来删除元素。
现在在你的例子中,我看到你从列表中删除了第一个元素,这个操作对于arraylist和linkedlist都是非常昂贵的,但是如果你尝试删除最后一个元素,那么arraylist肯定会比linkedlist快。

展开查看全部

相关问题