ArrayList和LinkedList的简单实现

原创 2017年07月31日 11:49:44
  • ArrayList提供了一宗可增长数组的实现。有点事对get和set调用花费常数时间。缺点是插入和删除代价昂贵,除非插入和删除是在ArrayList的末端进行。
  • LinkedList提供了双链表实现。优点是,插入和删除开销很小,花费常数时间。缺点是不容易做索引,get和set调用昂贵,除非调用接近表的断点的项(离哪端近就从哪端开始)。

原文地址:http://blog.csdn.net/qq_25806863/article/details/76423425

这两个集合主要是内部对数据的存储方式不一样,一个用的数组,一个用的链表。

数组和链表

关于数组合链表在之前有个简单的比较

简单数组

array list

  • 数组可以使遍历以线性时间执行O(N)
  • 查找是常数时间O(1)
  • 不过插入和删除开销昂贵,如果发生在第一个元素上,时间是O(N),如果发生在最后一个元素上也就是高端,时间是O(1)

当插入和删除都只对高端操作,数组也比较合适,否则就应用 链表 linked list

简单链表

使用链表是因为链表在内存中是不连续的,不用因为一个元素的插入或删除而引起其他元素的变动。

一般链表

链表由一系列节点组成,节点不需要在内存中相连,因此每一个节点除了自身元素外还要包含自己的后继元的节点的链(link),称之为next链。最后一个节点的next链引用null。

  • 遍历的时间是O(N),跟数组一样。
  • 查找的时间,因为需要从第一个节点开始查找,所以时间也是线性的,O(N) 。要查找第x个元素,花费的时间是O(x), 效率不如数组。
  • 删除可以通过修改next链的引用来实现
  • 插入也一样,获取一个新节点,修改两个next链的引用,

删除A2:

删除一个元素

在A1后插入Ax:

插入

双链表

让每一个节点拥有其前驱节点的引用就成了双链表。

双链表

ArrayList和LinkedList

  • ArrayList提供了一宗可增长数组的实现。有点事对get和set调用花费常数时间。缺点是插入和删除代价昂贵,除非插入和删除是在ArrayList的末端进行。
  • LinkedList提供了双链表实现。优点是,插入和删除开销很小,花费常数时间。缺点是不容易做索引,get和set调用昂贵,除非调用接近表的断点的项(离哪端近就从哪端开始)。

ArrayList的实现

  • 内部使用数组来保存数据,有一个默认的数组容量
  • 当容量不够的时候,扩容一个新数组,将老数据复制到新数组,释放旧数组。
  • 内部类实现 MyIterator
  • 增强for循环的实现 implements Iterable
import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.function.Consumer;

/**
 * @author sll on 2017/6/30.
 */
public class MyArrayList<Element> implements Iterable<Element> {
    private static final int DEFAULT_CAPACITY = 5;
    private int size;
    private Element[] elements;
    private int modCount = 0;

    public MyArrayList() {
        elements = (Element[]) new Object[DEFAULT_CAPACITY];
        clear();
    }

    public void clear() {
        size = 0;
        ensureCapacity(DEFAULT_CAPACITY);
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void trimToSize() {
        ensureCapacity(size);
    }

    //这里是查找,使用数组直接就查出来了,所以一次查询的时间是 O(1)
    public Element get(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        return elements[index];
    }

    public Element set(int index, Element newElement) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException();
        }
        Element old = elements[index];
        elements[index] = newElement;
        return old;
    }

    public boolean add(Element e) {
        return add(size, e);
    }


    //这里的增加和删除就要移动很多项,所以一次插入或删除的速度是 O(N)
    public boolean add(int index, Element e) {
        if (elements.length == size) {
            ensureCapacity(size * 2 + 1);
        }
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = e;
        size++;
        modCount++;
        return true;
    }

    public Element remove(int index) {
        Element removeElement = elements[index];
        int moveNum = size - index - 1;
        if (moveNum > 0) {
            System.arraycopy(elements, index + 1, elements, index, moveNum);
        }
        size--;
        elements[size] = null;
        modCount++;
        return removeElement;
    }

    public void ensureCapacity(int newCapacity) {
        if (newCapacity < size)
            return;
        elements = Arrays.copyOf(elements, newCapacity);
    }


    public Itr iterator() {
        return new Itr();
    }


    private class Itr implements Iterator<Element> {
        private int exceptMocCount = modCount;
        private int current = 0;

        @Override
        public boolean hasNext() {
            return current < size();
        }

        @Override
        public Element next() {
            if (exceptMocCount != modCount) {
                throw new ConcurrentModificationException();
            }
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return elements[current++];
        }

        @Override
        public void remove() {
            if (exceptMocCount != modCount) {
                throw new ConcurrentModificationException();
            }
            MyArrayList.this.remove(--current);
        }

        @Override
        public void forEachRemaining(Consumer<? super Element> action) {

        }
    }
}

LinkedList的实现

  • 使用双链表来实现
  • 节点类Node,为私有静态内部类(嵌套类),包含数据和前后节点的链
  • 有两个额外的节点,头节点和尾节点,中间才是数据
  • 内部实现MyIterator
  • 增强for循环的实现 implements Iterable
  • 对add和remove增加一个计数modCount,在迭代器的hasNext和next中比较这个计数,不同就说明这个集合被修改了,就抛出异常ConcurrentModificationException。
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * @author sll on 2017/6/30.
 */
public class MyLinkedList<E> implements Iterable<E> {

    private int theSize = 0;
    private int modCount = 0;
    private Node<E> startNode, endNode;//额外的头节点和尾节点

    public MyLinkedList() {
        clear();
    }

    private void clear() {
        startNode = new Node(null, null, null);
        endNode = new Node(null, startNode, null);
        startNode.next = endNode;
        theSize = 0;
        modCount++;
    }

    public int size() {
        return theSize;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean add(E x) {
        return add(size(), x);
    }

    public boolean add(int index, E x) {
        addBefore(getNode(index), x);
        return true;
    }

    public E get(int index) {
        return getNode(index).data;
    }

    public E set(int index, E x) {
        Node<E> p = getNode(index);
        E old = p.data;
        p.data = x;
        return old;
    }

    public E remove(int index) {
        return remove(getNode(index));
    }


    private void addBefore(Node<E> p, E x) {
        Node<E> newNode = new Node<>(x, p.prev, p);
        newNode.prev.next = newNode;
        p.prev = newNode;
        theSize++;
        modCount++;
    }

    private Node<E> getNode(int index) {
        Node<E> p;
        if (index < 0 || index > size())
            throw new IndexOutOfBoundsException();
        if (index < size() / 2) {
            p = startNode.next;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
        } else {
            p = endNode;
            for (int i = size(); i > index; i--) {
                p = p.prev;
            }
        }

        return p;
    }

    private E remove(Node<E> x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
        theSize--;
        modCount++;
        return x.data;
    }

    @Override
    public Iterator<E> iterator() {
        return new MyIterator();
    }

    private static class Node<E> {
        public E data;
        public Node<E> prev;
        public Node<E> next;

        public Node(E data, Node<E> prev, Node<E> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

    private class MyIterator implements Iterator<E> {
        private Node<E> current = startNode.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;

        @Override
        public boolean hasNext() {
            return current!= endNode;
        }

        @Override
        public E next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            E nextItem = current.data;
            current = current.next;
            okToRemove = true;
            return nextItem;
        }

        @Override
        public void remove() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (!okToRemove) {
                throw new NoSuchElementException();
            }
            MyLinkedList.this.remove(current.prev);
            okToRemove = false;
            expectedModCount++;
        }

    }


}

时间对比

以分别用ArrayList和LinkedList用下面三个方法做一个时间对比:

//从末端添加,创建一个由N个项的List。
public static void makeList1(List<Integer> list, int N) {
    list.clear();
    for (int i = 0; i < N; i++) {
        list.add(i);
    }
}

//从首端添加,创建一个由N个项的List。
public static void makeList2(List<Integer> list, int N) {
    list.clear();
    for (int i = 0; i < N; i++) {
        list.add(0, i);
    }
}

//获取长度为N的List的每一个值求和。
public static void makeList3(List<Integer> list) {
    long total = 0;
    for (int i = 0; i < list.size(); i++) {
        total += list.get(i);
    }
}

首先创建两个集合,N=100000,打印耗费时间(ms):

List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<Integer>();
  • makeList1

    makeList1(arrayList, 100000);
    makeList1(linkedList, 100000);

    结果可能会不一样,但也是相近的。

    运行时间都是O(N)

  • makeList2

    makeList2(arrayList, 100000);
    makeList2(linkedList, 100000);

    linkedList花费的时间少得多,执行时间是O(N)

    而ArrayList因为每次在头部插入都需要将之前所有项向后移动一位,所以执行时间是O(N^2)

  • makeList3

    makeList2(arrayList, 100000);
    makeList2(linkedList, 100000);
    
    makeList3(arrayList);
    makeList3(linkedList);

​ 这个每次都要查找,所以ArrayList比较快,执行时间是O(N)

​ 而inkedList的执行时间是O(N^2)

  • 用迭代器实现makeList3

    将makeList3改成:

    public static void makeList3(List<Integer> list) {
          long total = 0;
          for (Integer i : list) {
              total+=i;
          }
      }

​ 两个都很相近了,都是O(N)。

参考《数据结构与算法分析java版》

版权声明:

相关文章推荐

java中的线性表的内部实现(ArrayList、LinkedList)

线性表是一种抽象数据leixien

java的List接口的实现类 ArrayList,LinkedList,Vector 的区别

Java的List接口有3个实现类,分别是ArrayList、LinkedList、Vector,他们用于存放多个元素,维护元素的次序,而且允许元素重复。 3个具体实现类的区别如下:       ...

Java集合之ArrayList和LinkedList的实现原理以及Iterator详解

ArrayList实现可变数组的原理:   当元素超出数组内容,会产生一个新数组,将原来数组的数据复制到新数组中,再将新的元素添加到新数组中。   ArrayList:是按照原数组的50%来延长,...

实现一个基于LinkedList的队列数据结构,去除ArrayList集合中重复的元素,

/* 需求:实现一个基于LinkedList的队列数据结构 构造方法:               LinkedList()              ...

ArrayList,LinkedList,Vector的实现及区别

List接口继承Collection接口,Collection接口继承Iterable接口。实现List接口的子类必须实现Iterable和Collection接口中的方法。Iterable可以进行元...

ArrayList与LinkedList底层实现与增删查效率比较

我们知道ArrayList是List接口的一个实现类,它的特点是查询效率高,增删效率低,线程不安全 原因是因为ArrayList底层是封装了一个数组,它是用数组实现的。 看下图,数组在内存中的存储...
  • stanxl
  • stanxl
  • 2015-03-23 18:41
  • 4439

java实现ArrayList LinkedList 和迭代器

话不多说直接上代码: package com.moshi.iterator2; public interface List { boolean add(R r); boolean isEempty...

[Java]ArrayList与LinkedList的模拟实现

Java中的List继承自Collection接口。List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问L...

四、ArrayList和LinkedList内部的实现大致是怎样的?

1、ArrayList集合      ArrayList是List接口的一个实现类,它是程序中最常见的一种集合。在ArrayList内部封装了一个长度可变的数组对象,当存入的元素超过数组长度时,Ar...
  • WeDoi
  • WeDoi
  • 2017-06-29 20:48
  • 242

Java之实现自己的ArrayList与LinkedList

Java之实现自己的ArrayList与LinkedList
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)