纯手写LinkedList集合框架

LinkeList原理

LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。

LinkedList数据结构原理

LinkedList底层的数据结构是基于双向循环链表的，且头结点中不存放数据,如下： 

既然是双向链表，那么必定存在一种数据结构——我们可以称之为节点，节点实例保存业务数据，前一个节点的位置信息和后一个节点位置信息，如下图所示： 

数组和链表结构对比

数组　是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中。同样的道理，如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。如果应用需要快速访问数据，很少插入和删除元素，就应该用数组。

链表　中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起，每个结点包括两个部分：一个是存储 数据元素 的　数据域，另一个是存储下一个结点地址的 指针。

 

　如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表。

内存存储区别

数组从栈中分配空间, 对于程序员方便快速,但自由度小。

链表从堆中分配空间, 自由度大但申请管理比较麻烦.　

逻辑结构区别

数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。　

链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）　

总结

1、存取方式上，数组可以顺序存取或者随机存取，而链表只能顺序存取；　

2、存储位置上，数组逻辑上相邻的元素在物理存储位置上也相邻，而链表不一定；　

3、存储空间上，链表由于带有指针域，存储密度不如数组大；　

4、按序号查找时，数组可以随机访问，时间复杂度为O(1)，而链表不支持随机访问，平均需要O(n)；　

5、按值查找时，若数组无序，数组和链表时间复杂度均为O(1)，但是当数组有序时，可以采用折半查找将时间复杂度降为O(logn)；　

6、插入和删除时，数组平均需要移动n/2个元素，而链表只需修改指针即可；　

7、空间分配方面：

　　数组在静态存储分配情形下，存储元素数量受限制，动态存储分配情形下，虽然存储空间可以扩充，但需要移动大量元素，导致操作效率降低，而且如果内存中没有更大块连续存储空间将导致分配失败；

链表存储的节点空间只在需要的时候申请分配，只要内存中有空间就可以分配，操作比较灵活高效；

相关代码

package com.xhz.linkedlist;

/**
 * 纯手写LinkedList
 * 
 * @author xhz
 *
 * @param 
 */
public class ExtLinkedList {
	// 链表实际存储元素
	private int size;

	// 第一个元素(头节点,为了查询开始）
	private Node first;

	// 最后一个元素(头节点,为了添加开始)
	private Node last;

	// 添加元素
	public void add(E e) {
		// 创建节点
		Node node = new Node();
		// 给节点赋值
		node.object = e;
		if (first == null) {
			// 添加第一个元素
			// 给第一个元素赋值node节点赋值
			first = node;
			// 第一个元素头和尾都属于自己
		} else {
			// 添加第二个或以上数据
			node.prev = last;
			// 将上一个元素的next赋值
			last.next = node;
		}
		last = node;
		// 实际长度++
		size++;
	}

	// 按照指定索引插入元素
	public void add(int index, E e) {
		// 下标的验证
		checkElementIndex(index);
		// node2节点
		ExtLinkedList.Node oldNode = getNode(index);
		if (oldNode != null) {
			// node1
			ExtLinkedList.Node oldPrevNode = oldNode.prev;
			// 新增node节点
			// node4
			Node newNode = new Node();
			newNode.object = e;

			// node4下一个节点为node2
			newNode.next = oldNode;
			if (oldPrevNode == null) {
				first = newNode;
			} else {
				// node4上一个节点为node1
				newNode.prev = oldPrevNode;
				// node1下一个节点为node4
				oldPrevNode.next = newNode;
			}
			// node2的上一个节点为node4
			oldNode.prev = newNode;
			size++;
		}
	}

	// 链表节点存储元素
	private class Node {
		// 存放元素的值
		Object object;
		// 上一个节点Node
		Node prev;
		// 下一个节点Node
		Node next;
	}

	// 按照下标查询
	public Object get(int index) {
		// 下标的验证
		checkElementIndex(index);
		return getNode(index).object;
	}

	// 按照下标获得节点
	public Node getNode(int index) {
		// 下标的验证
		checkElementIndex(index);
		Node node = null;
		if (first != null) {
			node = first;// 默认取第0个
			for (int i = 0; i < index; i++) {
				node = node.next;
			}
		}
		return node;
	}

	// 按照指定下标删除
	public void remove(int index) {
		checkElementIndex(index);
		// 1.先获取当前删除node节点
		ExtLinkedList.Node oldNode = getNode(index);
		if (oldNode != null) {
			// 2.获取删除元素的上下节点
			// node3
			ExtLinkedList.Node oldNextNode = oldNode.next;
			// node1
			ExtLinkedList.Node oldPrevNode = oldNode.prev;
			// 将node1的下一个节点变为node3
			if (oldPrevNode == null) {
				// 删除第一个元素从新换头
				first = oldNextNode;
			} else {
				oldPrevNode.next = oldNextNode;
				oldNode.prev = null;
			}
			// 将node3的上一个节点变为node1
			if (oldNextNode == null) {
				last = oldPrevNode;
			} else {
				oldNextNode.prev = oldPrevNode;
				oldNode.next = null;
			}
			oldNode.object = null;
			// 让垃圾回收机制回收
			size--;
		}
	}

	// 检查下标是否越界
	public void checkElementIndex(int index) {
		if (!isElementIndex(index)) {
			throw new IndexOutOfBoundsException("查询越界啦！");
		}
	}

	private boolean isElementIndex(int index) {
		return index >= 0 & index < size;
	}

	// 大小
	public int size() {
		return size;
	}

	public static void main(String[] args) {
		ExtLinkedList extLinkedList = new ExtLinkedList();
		extLinkedList.add("a");
		extLinkedList.add("b");
		extLinkedList.add("c");
		extLinkedList.add("d");
		System.out.println("########################################");
		System.out.println(extLinkedList.first.object);
		System.out.println(extLinkedList.first.next.object);
		System.out.println(extLinkedList.first.next.next.object);
		System.out.println(extLinkedList.first.next.next.next.object);
		System.out.println("########################################");
		// 其实从头查到尾,效率不高，查询算法：折半查找(二分法)
		for (int i = 0; i < extLinkedList.size; i++) {
			System.out.println(extLinkedList.get(i));
		}
		System.out.println("长度：" + extLinkedList.size());
		System.out.println("########################################");
		extLinkedList.add(3, "小盒子");
		for (int i = 0; i < extLinkedList.size; i++) {
			System.out.println(extLinkedList.get(i));
		}
		System.out.println("########################################");
		System.out.println("删除之前：" + extLinkedList.get(2));
		extLinkedList.remove(2);
		System.out.println("删除之后：" + extLinkedList.get(2));
		System.out.println("########################################");
	}

}

控制台打印结果：

########################################
a
b
c
d
########################################
a
b
c
d
长度：4
########################################
a
b
c
小盒子
d
########################################
删除之前：c
删除之后：小盒子
########################################