数组
| 数组 | ||||
| 数组类型 | 不可重复 无序(线性查找) | 可重复(找到第一个即可) 无序(线性查找) | 不可重复 有序(二分查找) | 可重复(找到第一个即可) 有序(二分查找) |
| 插入 | 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);
大小固定
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可以自动扩展，但是以牺牲效率为代价的。
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容量扩展源码分析
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; } }
链表
除非频繁通过下标访问各个数据，否则都可以使用链表代替数组
链表也可以是有序的无序的，可重复的不可重复的
简单的一个链表定义
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是一个双端链表、双向链表。
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
扫一扫
2548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
