数组、ArrayList、链表、LinkedList
数组
数组 | ||||
数组类型 |
不可重复 无序(线性查找) |
可重复(找到第一个即可) 无序(线性查找) |
不可重复 有序(二分查找) |
可重复(找到第一个即可) 有序(二分查找) |
插入 | O(N) |
O(1) |
O(logN+N) | O(logN+N) |
查询 | O(N) | O(N) | O(logN) | O(logN) |
删除(无洞) | O(N) | O(N) | O(lonN+N) | O(logN+N) |
总结 | 可重复无序插入快、下标已知更新查找快;查找删除慢、大小固定 | 查找快;插入删除慢、大小固定 | ||
应用 | 员工表,雇用解雇不经常发生 | |||
java数组 | 无序、可重复;插入快、查询删除慢、大小固定;如果已知下标,更新查找快 | |||
ArrayList | 大小可以扩展;但这是以牺牲效率为代价的 | |||
Vector | 大小可以扩展;但这也是以牺牲效率为代价的 |
java 数组(无序、可重复)
已知下标查找更新快O(1)
String str = strs[1];
strs[1] = "花";
查找慢O(N)
int index = findChar("花", strs);
删除慢O(N)
deleteChar("花", strs);
中部插入慢O(N)
insertCharWithMiddle("兴", 1, strs);
大小固定
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public static void main(String[] args) { String[] strs = {"中", "华", "人", "民", "共", "和", "国", null, null, null, null}; print(strs); // 已知下标查找更新快 System.out.println(strs[1]); strs[1] = "花"; print(strs); // 查找慢,需要花费O(N)的时间 int index = findChar("花", strs); if (index == strs.length) { System.out.println("Can't find this char"); } else { System.out.println("Find this char"); } // 删除慢,需要花费O(N)的时间 deleteChar("花", strs); print(strs); // 中部插入慢,需要花费O(N)的时间 insertCharWithMiddle("兴", 1, strs); print(strs); } private static void insertCharWithMiddle(String str, int index, String[] strs) { for (int i = strs.length - 2; i >= index; i--) { strs[i + 1] = strs[i]; } strs[index] = str; } private static void deleteChar(String str, String[] strs) { int index = findChar(str, strs); if (index != strs.length) { for (int i = index; i < strs.length - 2; i++) { strs[i] = strs[i + 1]; } strs[strs.length - 1] = null; } } public static int findChar(String str, String[] strs) { for (int i = 0; i < strs.length; i++) { if (strs[i].equals(str)) { return i; } } return strs.length; } public static void print(String[] strs) { System.out.println(Arrays.asList(strs)); }
ArrayList
末尾插入快,已知下标查找快更新快
一个参数的add("xxx")方法效率高O(1)
get(1)方法效率高O(1)——已知下标查找快
set(1, "xxx")方法效率高O(1)——已知下标更新快
中部插入、查询、删除慢
add(1, "xxx")方法效率低O(N)——中部插入
contains、indexOf方法效率低O(N)——查询慢
remove(1),remove("xxx")方法效率低O(N)——删除慢
数组固定大小,虽然ArrayList可以自动扩展,但是以牺牲效率为代价的。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public static void main(String[] args) { List<String> list = new ArrayList<>(8); // add方法效率高O(1) list.add("中"); list.add("华"); list.add("人"); list.add("民"); list.add("共"); list.add("和"); list.add("国"); System.out.println(list); // get(1),方法效率高O(1),如果知道下标查找快 System.out.println(list.get(1)); // add(1, "xxx")方法效率低O(N),中部插入慢 list.add(1, "花"); System.out.println(list); // 删除慢O(N) list.remove(1); list.remove("人"); System.out.println(list); // contains、indexOf方法都比较慢,需要O(N)的时间 System.out.println(list.contains("中"));; System.out.println(list.indexOf("中")); }
ArrayList容量扩展源码分析
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
package java.util; import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.UnaryOperator; import sun.misc.SharedSecrets; public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { // 默认容量是10 private static final int DEFAULT_CAPACITY = 10; // 默认最大容量是MAX_ARRAY_SIZE,实际可以扩展至Integer的最大值 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; public boolean add(E e) { // ensure /ɪn'ʃʊə/ 确保 Capacity /kəˈpæsəti/ 容量 ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); int numNew = a.length; // 原来数组的元素个数加上新集合的容量 ensureCapacityInternal(size + numNew); // Increments modCount System.arraycopy(a, 0, elementData, size, numNew); size += numNew; return numNew != 0; } private void ensureCapacityInternal(int minCapacity) { if (elementData == EMPTY_ELEMENTDATA) { // System.out.println(Math.max(10, 11)); 输出11,比较两个数字,返回大的数字 minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); } private void ensureExplicitCapacity(int minCapacity) { // 父类的一个成员变量,应该是修改次数的记录 modCount++; // 数组容量不够 if (minCapacity - elementData.length > 0) // grow /grəʊ/ 扩大 grow(minCapacity); } private void grow(int minCapacity) { int oldCapacity = elementData.length; // System.out.println(20 >> 1); 结果是20的二分之一,10 // 1、扩展后的数组是原来数组加上原来数组的一半,适用于add(E e)方法 // add(int index, E e)指定的下标越界会报异常,下标必须正确,不存在扩容 int newCapacity = oldCapacity + (oldCapacity >> 1); // 2、扩展后的数组是指定的下标值,比如原有容量是10,addAll一个有8个元素的集合 if (newCapacity - minCapacity < 0) newCapacity = minCapacity; // 3、扩展后的数组是Integer的最大值,默认的最大值是Integer.MAX_VALUE - 8 // private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); elementData = Arrays.copyOf(elementData, newCapacity); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; } }
链表
除非频繁通过下标访问各个数据,否则都可以使用链表代替数组
链表也可以是有序的无序的,可重复的不可重复的
简单的一个链表定义
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
class Link { private long id; // data private String name; // data private byte age; // data private String address; // data private Link next; } class LinkList { private Link first; }
最后一个元素的next引用是null
单链表
insertFirst();
deleteFirst();
isEmpty(); // 是否为空
find(); // 遍历,查找指定Link
delete(); // 遍历,删除指定Link
insertAfter(); // 遍历,插入
双端链表
新增对最后一个Link的引用
insertLast();
表头多次插入会颠倒Link插入的顺序;表尾多次插入会保持Link插入的顺序
双端链表也不能提高删除最后一个链接点的效率
链表的效率
表头插入查询删除快,O(1)
中部插入查询删除慢,需要O(N)次比较;在数组中执行这些操作也需要O(N)次比较,但是链表仍然要快一些,因为链表不需要移动元素,只需要比较,而复制时间大于比较时间
有序链表
只有insert()方法与无序链表中的insert()方法不同
效率:插入删除O(N),删除最小值O(1)
双向链表
每个Link多了一个指向前一个元素的引用
第一个元素指向前一个元素的引用是null
双向链表的缺点是每次插入或删除一个Link的时候,要处理四个链接点的引用,而不是两个
双向链表不必是双端链表
deleteLast();
链表迭代器
实现从链接点到链接点步进,以提高效率
java LinkedList
java里的LinkedList是一个双端链表、双向链表。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public static void main(String[] args) { LinkedList<String> strings = new LinkedList<>(); strings.add("1");// 末尾添加 strings.add(1,"2");// 遍历,for循环的i和index比较,在Node里并没有成员变量index strings.addFirst("3"); strings.addLast("4"); strings.contains("5");// 遍历 strings.element();//返回第1项 strings.get(1);// 遍历,for循环的i和index比较 strings.getFirst(); strings.getLast(); strings.indexOf("6");// 遍历,for循环里index递增并返回 strings.offer("7");// 末尾添加 strings.offerFirst("8");// 表头添加 strings.offerLast("9");// 末尾添加 strings.peek();// 返回第1项 strings.peekFirst(); strings.peekLast(); strings.poll(); strings.pollFirst(); strings.pollLast(); strings.pop();// 弹出第1项 strings.push("");// 添加到第1项 strings.remove(); //删除第1项 strings.remove(1); strings.remove("10"); strings.removeFirst(); strings.removeLast(); }
java ArrayList和LinkedList
ArrayList底层是一个无序的可重复的数组,LinkedList底层是一个双端双向链表。
除非频繁地通过下标查询数据,否则都可以使用LinkedList来代替;LinkedList不需要扩容,直接在链表末尾添加元素,如果是添加一个集合,使用for循环。
首尾查询插入删除
ArrayList尾部插入快O(1)
LinkedList首尾插入快O(1)
中部查询插入删除
ArrayList中部插入删除O(N),N
LinkedList中部插入删除O(N),N/2