概要

线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分：数组、单向链表、双向链表；随后给出双向链表的C、C++和Java三种语言的实现。内容包括：

出处：http://www.cnblogs.com/skywang12345/p/3561803.html

数组

数组有上界和下界，数组的元素在上下界内是连续的。

存储10,20,30,40,50的数组的示意图如下：

数组的特点是：数据是连续的；随机访问速度快。
数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维数组实现的。至于动态数组，是指数组的容量能动态增长的数组；对于C语言而言，若要提供动态数组，需要手动实现；而对于C++而言，STL提供了Vector；对于Java而言，Collection集合中提供了ArrayList和Vector。

单向链表

单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

单链表的示意图如下：

表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，...

单链表删除节点

删除"节点30"
删除之前："节点20" 的后继节点为"节点30"，而"节点30" 的后继节点为"节点40"。
删除之后："节点20" 的后继节点为"节点40"。

单链表添加节点

在"节点10"与"节点20"之间添加"节点15"
添加之前："节点10" 的后继节点为"节点20"。
添加之后："节点10" 的后继节点为"节点15"，而"节点15" 的后继节点为"节点20"。

单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

双向链表

双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双链表的示意图如下：

表头为空，表头的后继节点为"节点10"(数据为10的节点)；"节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；"节点20"的后继节点是"节点30"，"节点30"的前继节点是"节点20"；...；末尾节点的后继节点是表头。

双链表删除节点

删除"节点30"
删除之前："节点20"的后继节点为"节点30"，"节点30" 的前继节点为"节点20"。"节点30"的后继节点为"节点40"，"节点40" 的前继节点为"节点30"。
删除之后："节点20"的后继节点为"节点40"，"节点40" 的前继节点为"节点20"。

双链表添加节点

在"节点10"与"节点20"之间添加"节点15"
添加之前："节点10"的后继节点为"节点20"，"节点20" 的前继节点为"节点10"。
添加之后："节点10"的后继节点为"节点15"，"节点15" 的前继节点为"节点10"。"节点15"的后继节点为"节点20"，"节点20" 的前继节点为"节点15"。

下面介绍双链表的实现，介绍Java实现

双链表类(DoubleLink.java)

/*** Java 实现的双向链表。 * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList** @author skywang* @date 2013/11/07*/
public class DoubleLink<T> {// 表头private DNode<T> mHead;// 节点个数private int mCount;// 双向链表“节点”对应的结构体private class DNode<T> {public DNode prev;public DNode next;public T value;public DNode(T value, DNode prev, DNode next) {this.value = value;this.prev = prev;this.next = next;}}// 构造函数public DoubleLink() {// 创建“表头”。注意：表头没有存储数据！mHead = new DNode<T>(null, null, null);mHead.prev = mHead.next = mHead;// 初始化“节点个数”为0mCount = 0;}// 返回节点数目public int size() {return mCount;}// 返回链表是否为空public boolean isEmpty() {return mCount==0;}// 获取第index位置的节点private DNode<T> getNode(int index) {if (index<0 || index>=mCount)throw new IndexOutOfBoundsException();// 正向查找if (index <= mCount/2) {DNode<T> node = mHead.next;for (int i=0; i<index; i++)node = node.next;return node;}// 反向查找DNode<T> rnode = mHead.prev;int rindex = mCount - index -1;for (int j=0; j<rindex; j++)rnode = rnode.prev;return rnode;}// 获取第index位置的节点的值public T get(int index) {return getNode(index).value;}// 获取第1个节点的值public T getFirst() {return getNode(0).value;}// 获取最后一个节点的值public T getLast() {return getNode(mCount-1).value;}// 将节点插入到第index位置之前public void insert(int index, T t) {if (index==0) {DNode<T> node = new DNode<T>(t, mHead, mHead.next);mHead.next.prev = node;mHead.next = node;mCount++;return ;}DNode<T> inode = getNode(index);DNode<T> tnode = new DNode<T>(t, inode.prev, inode);inode.prev.next = tnode;inode.next = tnode;mCount++;return ;}// 将节点插入第一个节点处。public void insertFirst(T t) {insert(0, t);}// 将节点追加到链表的末尾public void appendLast(T t) {DNode<T> node = new DNode<T>(t, mHead.prev, mHead);mHead.prev.next = node;mHead.prev = node;mCount++;}// 删除index位置的节点public void del(int index) {DNode<T> inode = getNode(index);inode.prev.next = inode.next;inode.next.prev = inode.prev;inode = null;mCount--;}// 删除第一个节点public void deleteFirst() {del(0);}// 删除最后一个节点public void deleteLast() {del(mCount-1);}
}

View Code

ArrayList、Vector、LinkedList 区别与联系：

看图：

如上图所示：

　　ArrayList是实现了基于动态数组的数据结构，LinkedList基于双线链表的数据结构。

　　ArrayList可以随机定位对于新增和删除操作add和remove，LinedList比较占优势

　　具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

　　Vector与ArrayList唯一的区别是，Vector是线程安全的，即它的大部分方法都包含有关键字synchronized，因此，若对于单一线程的应用来说，最好使用ArrayList代替Vector，因为这样效率会快很多（类似的情况有StringBuffer线程安全的与StringBuilder线程不安全的）；而在多线程程序中，为了保证数据的同步和一致性，可以使用Vector代替ArrayList实现同样的功能。

主要区别：

1、ArrayList、Vector、LinkedList类都是java.util包中，均为可伸缩数组。

2、ArrayList和Vector底层都是数组实现的，所以，索引/查询数据快，删除、插入数据慢。

　　ArrayList采用异步的方式，性能好，属于非线程安全的操作类。（JDK1.2）

　　Vector采用同步的方式，性能较低，属于线程安全的操作类。（JDK1.0）

3、LinkedList底层是链表实现，所以，索引慢，删除、插入快，属于非线程安全的操作类。

java定义数组需要声明长度，然后arraylist基于数组，等同于一个动态数组的实现，但是查询比较慢，所以可以自己编写一个动态数组来实现，代码如下：

package com.newer.tw.com;/*** 自定义长度可变数组* * @author Administrator* */
public class MyList {// 定义一个初始长度为0的数组，用来缓存数据private String[] src = new String[0];// 增加public void add(String s) {//定义新数组，长度是原数组长度+1String[] dest = new String[src.length+1];//将原数组的数据拷贝到新数组System.arraycopy(src, 0, dest, 0, src.length);//将新元素放到dest数组的末尾dest[src.length]=s;//将src指向destsrc=dest;}// 修改指定位置的元素public void modify(int index, String s) {src[index]=s;}// 删除指定位置的元素public void delete(int index) {String[] dest = new String[src.length-1];//将原数组的数据拷贝到新数组System.arraycopy(src, 0, dest, 0, index);System.arraycopy(src, index+1, dest, index, src.length-1-index);src=dest;}// 获得指定位置的元素public String get(int index) {return src[index];}// 在指定位置插入指定元素public void insert(int index, String s) {//定义新数组，长度是原数组长度+1String[] dest = new String[src.length+1];//将原数组的数据拷贝到新数组System.arraycopy(src, 0, dest, 0, index);dest[index]=s;System.arraycopy(src, index, dest, index+1, src.length-index);src=dest;}// 获得元素个数public int size() {return src.length;}public void print(){for(int i=0;i<size();i++)System.out.println(src[i]);}public static void main(String[] args){MyList m=new MyList();m.add("15");m.add("16");m.add("17");m.add("18");m.add("19");System.out.println("插入之前：");m.print();m.insert(2,"22");System.out.println("插入之后：");m.print();    }}

View Code

Hashmap 原理

参考： https://blog.csdn.net/qa962839575/article/details/44889553

在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，hashmap也不例外。Hashmap实际上是一个数组和链表的结合体（在数据结构中，一般称之为“链表散列“），请看下图

从图中我们可以看到一个hashmap就是一个数组结构，当新建一个hashmap的时候，就会初始化一个数组。

/** * The table, resized as necessary. Length MUST Always be a power of two. *  FIXME 这里需要注意这句话，至于原因后面会讲到 */
transient Entry[] table;
static class Entry<K,V> implements Map.Entry<K,V> {  final K key;  V value;  final int hash;  Entry<K,V> next;
..........
}  

Entry就是数组中的元素，它持有一个指向下一个元素的引用，这就构成了链表。 
         当我们往hashmap中put元素的时候，先根据key的hash值得到这个元素在数组中的位置（即下标），然后就可以把这个元素放到对应的位置中了。如果这个元素所在的位子上已经存放有其他元素了，那么在同一个位子上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。从hashmap中get元素时，首先计算key的hashcode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。从这里我们可以想象得到，如果每个位置上的链表只有一个元素，那么hashmap的get效率将是最高的，

static int indexFor(int h, int length) {  return h & (length-1);  }  

首先算得key得hashcode值，然后跟数组的长度-1做一次“与”运算（&）。看上去很简单，其实比较有玄机。比如数组的长度是2的4次方，那么hashcode就会和2的4次方-1做“与”运算。很多人都有这个疑问，为什么hashmap的数组初始化大小都是2的次方大小时，hashmap的效率最高

当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了。 
          说到这里，我们再回头看一下hashmap中默认的数组大小是多少，查看源代码可以得知是16，为什么是16，而不是15，也不是20呢，看到上面annegu的解释之后我们就清楚了吧，显然是因为16是2的整数次幂的原因，在小数据量的情况下16比15和20更能减少key之间的碰撞，而加快查询的效率。

初始容量为16，初始负载因子loadFactor为0.75 ，当hashmap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为2*16=32，即扩大一倍；所以它带有动态的意义

初始容量与负载因子 

参考： https://www.cnblogs.com/haifeng1990/p/6262417.html

HashMap有两个参数影响性能，初始容量和负载因子