线性结构之数组和链表

上一篇：数据结构分类和算法优劣的衡量
下一篇：线性结构之栈和队列

1. 数组和链表

数组和链表都是线性表，数组是用连续的存储结构来实现线性表，而链表使用非连续的存储结构来实现线性表。
数组：在内存中，是一块连续的内存区域；
链表：是由不连续的内存空间组成(当然也有可能在连续的内存区域)；

2. 数组和链表在java中的实现

在java中数组的表示和使用：

        //直接使用数组
        String[] stringArray = new String[10];
        
        //使用java封装好的集合类
        ArrayList<String> stringArrayList = new ArrayList<>();
        //添加一个元素
        stringArrayList.add("abc");
        //检索指定位置元素
        String s = stringArrayList.get(0);
        //修改指定位置元素
        stringArrayList.set(0, "acde");
        //删除指定元素
        stringArrayList.remove("abc");
        //删除指定位置元素
        stringArrayList.remove(0);

ArrayList的实现

//ArrayList.java

 	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 	private static final int DEFAULT_CAPACITY = 10;
	transient Object[] elementData;
	private int size;
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //initialCapacity >= 0
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }    
    public boolean add(E e) {
    	//这里是把几个方法的代码拿到这个方法里面
        int minCapacity = size + 1;
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }  
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0) {
         // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
        }             
        elementData[size++] = e;
        return true;
    }       

从上面代码可以知道，使用无参数new ArrayList<>()构造函数初始化的ArrayList的长度为0，在第一次添加元素的时候会将长度初始化为DEFAULT_CAPACITY = 10；如果知道要使用的数组最大长度可以使用ArrayList(int initialCapacity)构造方法

• ArrayList和Object[]的区别

ArrayList是Object[]的进一步封装，比如，Object[]的长度不够的时候，ArrayList有扩容机制；Object[]中间添加/删除一个元素，ArrayList会帮你移动元素位置等；所以除非必要，使用数组的时候请使用ArrayList

在java中链表的表示和使用：

        LinkedList<String> stringLinkedList = new LinkedList<>();
        //添加一个元素
        stringLinkedList.add("abc");
        //检索指定位置元素
        String s1 = stringLinkedList.get(0);
        //修改指定位置元素
        stringLinkedList.set(0, "acde");
        //删除指定元素
        stringLinkedList.remove("abc");
        //删除指定位置元素
        stringLinkedList.remove(0);

LinkedList的实现

//LinkedList.java

    transient Node<E> first;//头的位置
    transient Node<E> last;//尾的位置
    
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }    

可以知道LinkedList的实现是持有一个头指针和尾指针，节点是双向的，所以是一个双向链表

tips:
问题一：单链表的反转实现
问题二：找出单链表的中间位置

3. 数组和链表的比较

比较项	数组	链表
随机访问性	随机访问性强，查找速度快，直接根据下标访问	不能随机查找，必须从第一个开始遍历，查找效率低
增加/删除一个元素	分两种情况：末尾插入或者删除，时间复杂度为O(1),如果添加元素的时候数组长度不够，还需要扩容和拷贝数据,时间复杂度为O(n)；非末尾插入，数组长度不够，需要扩容，之后再拷贝数据；数组长度够，就直接拷贝要插入位置之后的数据,时间复杂度为O(n)	也分两种情况：两头插入或者删除，只需要改变头或者尾引用，时间复杂度为O(1)；中间位置插入或者删除，需要先遍历找到需要的位置，再修改引用关系，时间复杂度为O(N)。和数组比较时间复杂度是一样的，而数组的空间复杂度也是O(n),链表是O(1);所以增加和
查找一个元素	无序的数组需要遍历一遍 ，而有序的数组可以很好的使用二分查找	无序的链表需要遍历一遍，有序的链表不能很好的使用二分查找
修改一个元素	这个是基于查找的，查找到所需的元素直接修改	这个是基于查找的，查找到所需的元素直接修改

上一篇：数据结构分类和算法优劣的衡量
下一篇：线性结构之栈和队列

---

此文要是对你有帮助，如果方便麻烦点个赞，谢谢！！！