数据结构 -- 链表（LinkedList）

　　链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。

　　每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

　　相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

　　链表这类数据结构，有点像生活中的火车，一节车厢连着下一节车厢，在火车里面，只有到了4号车厢你才能进入5号车厢，一般情况下，不可能直接在3号车厢绕过4号车厢进入5号车厢。不过更准确来说，火车是双向链表，也就是说在4号车厢也可以反向进入3号车厢。

二、链表种类

　　　　1.1）单向链表：

　　　　　　element：用来存放元素

　　　　　　next：用来指向下一个节点元素

　　　　　　通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。

　　　　　　

　　　　1.2）单向循环链表

　　　　　　element、next 跟前面一样

　　　　　　在单向链表的最后一个节点的next会指向头节点，而不是指向null，这样存成一个环

　　　　　　

　　　　1.3）双向链表

　　　　　　element：存放元素

　　　　　　pre：用来指向前一个元素

　　　　　　next：指向后一个元素

　　　　　　双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。

　　　　　　

　　　　1.4）双向循环链表

　　　　　　element、pre、next 跟前面的一样

　　　　　　第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。

　　　　　　

　　时间复杂度

　　（1）添加操作：O(n)

　　　　① addLast(e): O(n)  ②addFirst(e): O(1)  ③add(index, e): O(n/2)=O(n)

　　（2）删除操作：O(n)

　　　　① removeLast(e): O(n)  ②removeFirst(e): O(1)  ③remove(index, e): O(n/2)=O(n)

　　（3）查找操作：O(n)

　　　　① get(index): O(n)  ②contains(e): O(n)

　　（4）修改操作：O(n)

　　　　① set(index，e): O(n)

三、代码实现

单链表的实现

图解如下：

插入

删除

代码

public class LinkedList<E> {
    //链表节点，使用内部类
    private class Node{
        public E e; //当前节点内容
        public Node next; //指向下一个节点
        public Node(E e, Node 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();
        size = 0;
    }

    public int getSize(){
        return size;
    }
    //判断是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    public void add(int index, E e){
        if(index < 0 || index > size){
            throw  new IllegalArgumentException("Add failed. Illegal index.");
        }
        Node prev = dummyHead;
        for (int i=0; i<index; i++){
            prev = prev.next;
        }
        prev.next = new Node(e,prev.next);
        size ++;
    }
    //在链表 表头添加新的元素e
    public void addFirst(E e){
        add(0,e);
    }
    //在链表 尾部添加新的元素e
    public void addList(E e){
        add(size,e);
    }

    //获得链表的第index位置的元素. 在链表中不是一个常用的操作，练习用
    public E get(int index){
        if(index < 0 || index >= size){
            throw  new IllegalArgumentException("index Illegal");
        }

        Node cur = dummyHead.next;
        for (int i =0; i<index; i++){
            cur = cur.next;
        }
        return cur.e;
    }

    public E getLast(){
        return get(size - 1);
    }
    public E getFirst(){
        return get(0);
    }

    public void set(int index,E e){
        if(index < 0 || index >= size){
            throw  new IllegalArgumentException("index Illegal");
        }

        Node cur = dummyHead.next;
        for (int i=0; i<index; i++){
            cur =cur.next;
        }
        cur.e = e;
    }

    //查找链表中是否包含元素e
    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(0-based)位置的元素, 返回删除的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E remove(int index){
        if (index < 0 || index >= size){
            throw  new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        Node prev = dummyHead;
        for (int i = 0; i < index; i++){
            prev = prev.next;
        }
        Node retNode = prev.next;
        prev.next = retNode.next;
        //删除retNode节点，则它的下一个节点指引就不需要了，设置null，让GC干活
        retNode.next = null;
        size --;
        return retNode.e;
    }

    public E removeFirst(){
        return remove(0);
    }

    public E removeLast(){
        return remove(size - 1);
    }

    public void removeElement(E e){
        Node prev = dummyHead;
        while (prev != null){
            if (prev.next.e.equals(e)){
                break;
            }
            prev = prev.next;
        }

        if (prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
        }
    }
    @Override
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        Node cur = dummyHead.next;
        while( cur != null){
            stringBuilder.append(cur + "- >");
            cur = cur.next;
        }
        stringBuilder.append("null");
        return  stringBuilder.toString();
    }
}

测试代码

public class LinkedListTest{
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        for (int i=0; i< 10; i++){
            linkedList.add(i,i*10);
            System.out.println(linkedList);
        }
        linkedList.remove(1);
        System.out.println(linkedList);
        linkedList.removeElement(50);
        System.out.println(linkedList);
    }
}

//测试结果
0- >null
0- >10- >null
0- >10- >20- >null
0- >10- >20- >30- >null
0- >10- >20- >30- >40- >null
0- >10- >20- >30- >40- >50- >null
0- >10- >20- >30- >40- >50- >60- >null
0- >10- >20- >30- >40- >50- >60- >70- >null
0- >10- >20- >30- >40- >50- >60- >70- >80- >null
0- >10- >20- >30- >40- >50- >60- >70- >80- >90- >null
0- >20- >30- >40- >50- >60- >70- >80- >90- >null //删除第二个位置的10
0- >20- >30- >40- >60- >70- >80- >90- >null  //删除指定元素50

　　链表实现队列

import com.wj.queue.Queue; //Queue连接：https://www.cnblogs.com/FondWang/p/11808221.html
public class LinkedListQueue<E> implements Queue<E> {
    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e=e;
            this.next = next;
        }

        public Node(){
            this(null,null);
        }

        public Node(E e){
            this(e,null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    private Node head, tail; //指针队首和队尾
    private int size; //数据个数

    public LinkedListQueue(){
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    //入队
    @Override
    public void enqueue(Object o) {
        if (tail == null){
            tail = new Node((E) o);
            head = tail;
        }else {
            tail.next = new Node((E) o);
            tail = tail.next;
        }
        size++;
    }
    //出队
    @Override
    public E dequeue() {
        if (isEmpty()){
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        Node retNode = head;
        head = head.next;
        retNode.next = null;
        if (head == null){
            tail = null;
        }
        size--;
        return retNode.e;
    }
    //返回队首元素
    @Override
    public E getFront() {
        if (isEmpty()){
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        return head.e;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Queue: front ");
        Node cur = head;
        while (cur != null){
            stringBuilder.append(cur + "- >");
            cur = cur.next;
        }
        stringBuilder.append("NULL tail");
        return stringBuilder.toString();
    }
}

测试类

public class LinkedListQueueTest{
     public static void main(String[] args) {
        LinkedListQueue linkedListQueue = new LinkedListQueue();
        for (int i=0; i<10; i++){
            linkedListQueue.enqueue(i);  //入队
            System.out.println(linkedListQueue);
            if (i % 3 ==0){
                linkedListQueue.dequeue();  //符合条件，出队
            }
        }
    }
}

//测试结果
Queue: front 0- >NULL tail
Queue: front 1- >NULL tail
Queue: front 1- >2- >NULL tail
Queue: front 1- >2- >3- >NULL tail
Queue: front 2- >3- >4- >NULL tail
Queue: front 2- >3- >4- >5- >NULL tail
Queue: front 2- >3- >4- >5- >6- >NULL tail
Queue: front 3- >4- >5- >6- >7- >NULL tail
Queue: front 3- >4- >5- >6- >7- >8- >NULL tail
Queue: front 3- >4- >5- >6- >7- >8- >9- >NULL tail

　　链表实现栈 

import com.wj.stack.Stack; //详情连接：https://www.cnblogs.com/FondWang/p/11809042.html
public class LinkedListStack<E> implements Stack<E> {

    private LinkedList<E> linkedList;

    public LinkedListStack(){
        linkedList = new LinkedList<>();
    }
    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    //压入
    public void push(Object o) {
        linkedList.addFirst((E) o);
    }
    //移除
    @Override
    public E pop() {
        return linkedList.removeFirst();
    }
    //返回栈首元素
    @Override
    public E peek() {
        return linkedList.getFirst();
    }

    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Stack: top ");
        stringBuilder.append(linkedList);
        return stringBuilder.toString();
    }
}

测试类

public class LinkedListStackTest{
        public static void main(String[] args) {
        LinkedListStack stack = new LinkedListStack();
        for (int i =0; i< 10; i++){
            stack.push(i); //压入
            System.out.println(stack);
        }

        System.out.println("=============");
        stack.pop(); //移除
        System.out.println(stack);
    }
}

//测试结果
Stack: top 0- >null
Stack: top 1- >0- >null
Stack: top 2- >1- >0- >null
Stack: top 3- >2- >1- >0- >null
Stack: top 4- >3- >2- >1- >0- >null
Stack: top 5- >4- >3- >2- >1- >0- >null
Stack: top 6- >5- >4- >3- >2- >1- >0- >null
Stack: top 7- >6- >5- >4- >3- >2- >1- >0- >null
Stack: top 8- >7- >6- >5- >4- >3- >2- >1- >0- >null
Stack: top 9- >8- >7- >6- >5- >4- >3- >2- >1- >0- >null //将第一个移除
=============
Stack: top 8- >7- >6- >5- >4- >3- >2- >1- >0- >null

四、效率对比

栈的对比

import com.wj.stack.ArrayStack; //详情连接：https://www.cnblogs.com/FondWang/p/11809042.html
import com.wj.stack.Stack;
import java.util.Random;
public class StackEfficiency {
    private static double testStack(Stack<Integer> stack, int opCount){
        long startTime = System.nanoTime();
        Random random = new Random();
        for (int i=0; i < opCount; i ++){
            stack.push(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i=0; i < opCount; i ++){
            stack.pop();
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }
    public static void main(String[] args) {
        int opCount = 100000;
        ArrayStack<Integer> arrayStack = new ArrayStack();
        double time1 = testStack(arrayStack,opCount);
        System.out.println("ArrayStack - time1: " + time1);

        LinkedListStack<Integer> linkedListStack = new LinkedListStack();
        double time2 = testStack(linkedListStack,opCount);
        System.out.println("LinkedListStack - time2: " + time2);

    }
}

//测试结果，添加和删除
ArrayStack - time1: 7.071363002
LinkedListStack - time2: 0.006395025
//说明数组的增删 效率要低于 链表。
//对于增删数组的时间复杂度是O(n)，而链表是O(1)

队列的对比

import com.wj.queue.ArrayQueue;//详情：https://www.cnblogs.com/FondWang/p/11808221.html
import com.wj.queue.LoopQueue;
import com.wj.queue.Queue;
import java.util.Random;
public class MainQueue {
    private static double testStack(Queue<Integer> queue, int opCount){
        long startTime = System.nanoTime();
        Random random = new Random();
        for (int i=0; i < opCount; i ++){
            queue.enqueue(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i=0; i < opCount; i ++){
            queue.dequeue();
        }

        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }
    public static void main(String[] args) {
        int opCount = 1000000;
　　　　　　
        ArrayQueue<Integer> arrayQueue = new ArrayQueue();
        double time1 = testStack(arrayQueue,opCount);
        System.out.println("ArrayStack - time1: " + time1);

        LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue();
        double time2 = testStack(linkedListQueue,opCount);
        System.out.println("LinkedListStack - time2: " + time2);

        LoopQueue<Integer> loopQueue = new LoopQueue();
        double time3 = testStack(loopQueue,opCount);
        System.out.println("LoopQueue - time3: " + time3);
    }
}

//测试结果
ArrayQueue - time1: 368.014648575
LinkedListQueue - time2: 0.395344446
LoopQueue - time3: 0.045756219
//对于增删操作，数组（O(n)）的时间复杂度高于链表队列和循环队列，所以数组最慢。
//链表和队列。队列增删只在队首和队尾，时间复杂度低于链表，所以循环队列要高于链表队列。