1. 表的java实现

咱们程序员入门C语言一开始就介绍的

1.1 数组实现?

主要就是查询快，删除，插入 时间复杂度O(N)，比如删除第一个元素，那么后面的元素就要整体向前移动，而查询就比较简单了时间复杂度O(1)

1.2 链表实现 :? 插入删除快，查询较复杂?

?

2. ArrayList 数组实现

? ? 预先定义的基本属性

?

class="java">     // 默认的容量
    private static  final  int DEFAULT_CAPACITY = 10;
    // 长度
    private int size;
    // 元素
    private E [] items;

?

2.1 capacity 容量?

capacity 是什么样一个概念：感觉很直观的理解就是一个预先估计的容量，为后面新来的元素有了一个准备，不必每次新添加元素这边都要做扩容处理影响效率。

?

public void ensureCapacity(int newCapacity){
        if ( newCapacity < size) {
            return;
        }

        E [] old = items;
        items = (E []) new Objects [newCapacity];

        for (int i = 0; i < size(); i++) {
            items [i] = old[i];
        }
    }

?

?

?2.2 add?

public void add (E ele) {
    add(size(), ele) ;
}

public void add (int index, E ele) {
    if ( items.length == size()) {
        // 扩容机制 jdk 1.5 倍 + 1
ensureCapacity (size() * 2 + 1);
    }
    // 插入点，向后移动，后面有位置
for ( int i = size; i > index; i-- ) {
        items [i] = items [i - 1];
    }
    items[index] = ele;
}

?

?2.3 remove

?

 public E remove (int index) {
        E removeItem = items[index];
        // 向前缩进
        for ( int i = index; i < size() - 1; i++) {
            items [i] = items[i - 1];
        }
        size --;
        return removeItem;
    }

?3.LinkedList 实现

? 3.1 Node 节点

? ?LinkedList 是双链表来实现的，由节点来构成的，因此我们同时定义了一个节点类Node(内部嵌套)

? ?

public 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;
        }
    }

? ?初始化

??

public MyLinkedList () {
    clear();
}

public void clear () {
    beginMarker = new Node<E>(null, null, null);
    endMarker= new Node<E>(null, beginMarker, null);
    beginMarker.next = endMarker;
    size = 0;
}

?

3.2 Node 插入点，删除点

?由于链表添加删除，与操作位置上的节点有关系因此操作前要获取位置上的操作节点

?

public Node<E> getNode (int index){

        return getNode(index, 0, size()-1);
    }

    public Node<E> getNode (int index, int lower, int upper){
        Node<E> p;
        if(index < lower || index > upper) {
            throw new IndexOutOfBoundsException();
        }
        // 判断从前开始还是从后开始，减少循环次数
        if (index < size()/2) {
            p = beginMarker;
            for (int i = 0; i < index; i++){
                p = p.next;
            }
        }else {
            p = endMarker;
            for (int i = size(); i > index; i--) {
                p = p.prev;
            }
        }
        return p;
    }

?

3.3 Node 新增

    public void add(int index, E ele){
        addBefore( getNode(index, 0, size()), ele);
    }

    public void addBefore(Node<E> p, E e){
        Node<E> newNode = new Node<E>(e, p.prev, p);
        p.prev.next = newNode;
        p.prev = newNode;
        size ++;
    }

?

3.3 Node 删除

public void romove(int index){
       romove(getNode(index, 0, size()-1));
    }
    public void romove(Node<E> p){
        p.prev.next = p.next;
        p.next.prev = p.prev;
        size--;
    }

?

?

?