链表
之前讲到的动态数组、栈、队列，底层都是依托静态数组，靠resize解决固定容量问题。而链表是一种真正的动态线性的数据结构。
*最简单的动态数据结构
*更加深入理解引用
*更深入的理解递归
*辅组组成其他数据结构
数据储存在节点（Node）中,优点： 真正的动态，不需要处理固定容量问题，缺点：丧失了随机访问的能力。
数组和链表的对比：
*数组最要用于索引有语意的情况。
*最大的优点：支持快速查询。
*链表不适合用于索引有语意的情况。
*最大的优点：动态。
实现链表的源码如下：
package linkedList;
/**
* 最简单的动态数据结构链表的实现
*
* @author zhangtianci
*
*/
public class LinkedList<E> {
private class Node<E>{
E e;
Node next;
public Node(E e,Node<E> next){
this.e = e;
this.next = next;
}
public Node(E e){
this(e, null);
}
public Node(){
this(null, null);
}
@Override
public String toString() {
return e.toString();
}
}
private Node dummyHead; //设置一个虚拟头结点
private int size; //记录链表中元素的个数
/**
* 无参构造方法
*/
public LinkedList(){
dummyHead = new Node<>(null,null);
size = 0;
}
/**
* 获得链表中元素的个数
*
* @return
*/
public int getSize(){
return size;
}
/**
* 判断链表是否为空
*
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 在链表的index位置上添加在，这在链表中并不是一个常用操作，练习用:)
*/
public void add(int index,E e){
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add failed.Illegal index.");
}
Node prev = dummyHead;
//获取index位置的前一个元素
for(int i = 0; i < index; i++){
prev = prev.next;
}
prev.next = new Node<E>(e, prev.next);
size++;
}
/**
* 在链表头添加一个新元素
*/
public void addFirst(E e){
add(0, e);
}
/**
* 在链表尾添加一个元素
* @param e
*/
public void addLast(E e){
add(size, e);
}
/**
* 获取链表中索引为index的元素
*
* @param index
* @return
*/
public E get(int index){
if (index < 0 || index > size) {
throw new IllegalArgumentException("Get failed.Illegal index.");
}
Node<E> cur = dummyHead;
for(int i = 0; i < index; i++){
cur = dummyHead.next;
}
return cur.e;
}
/**
* 获取链表的第一个元素
*
* @return
*/
public E getFirst(){
return get(0);
}
/**
* 获取链表的最后一个元素
*
* @return
*/
public E getLast(){
return get(size - 1);
}
/**
* 修改链表中索引为index的值
*
* @param index
* @param e
*/
public void set(int index,E e){
if (index < 0 || index > size) {
throw new IllegalArgumentException("Get failed.Illegal index.");
}
Node<E> cur = dummyHead;
for(int i = 0; i < index; i++){
cur = dummyHead.next;
}
cur.e = e;
}
/**
* 查看链表中是否存在该元素，若存在返回true，反之false
*
* @param e
* @return
*/
public boolean contains(E e){
Node cur = dummyHead.next;
while (cur != null) {
if (cur.e.equals(e)) {
return true;
}
cur = cur.next;
}
return false;
}
/**
* 移出链表中索引为index的元素并返回
*
* @param index
* @return
*/
public E remove(int index){
if (index < 0 || index > size) {
throw new IllegalArgumentException("Remove failed.Illegal index.");
}
Node prev = dummyHead;
for(int i = 0; i < index; i++){
prev = prev.next;
}
Node<E> cur = prev.next;
prev.next = cur.next;
cur.next = null;
size--;
return cur.e;
}
/**
* 移出链表中的第一个元素
*
* @return
*/
public E removeFirst(){
return remove(0);
}
/**
* 移出链表中的最后一个元素
*
* @return
*/
public E removeLast(){
return remove(size - 1);
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
Node cur = dummyHead.next;
while(cur != null){
res.append(cur + "->");
cur = cur.next;
}
res.append("NULL");
return res.toString();
}
}
简单的时间复杂度分析：
*添加操作：
addLast(E e) : O(n)
addFirst(E e) : O(1)
add(int index,E e) : O(n)
删除操作：
removeLast(E e) : O(n)
removeFirst(E e) : O(1)
remove(int index) : O(n)
修改操作:
set(int index,E e) ： O(n)
查找操作:
get(int index) : O(n)
contains(E e) : O(n)
综上所述，最好不要做修改操作，查询最好只要查链表头元素（时间复杂度为O(1)），对于增加和删除最好链表头进行操作（时间复杂度为O(1)）,同时链表是动态的不会大量的浪费空间，所以具有一定的优势。对链表来说还具有很多改进的地方。