链表

链表

链表是一种非常重要的线性数据结构，我们在实现栈和队列时使用的是动态数组实现的，这个动态数组是针对用户而言是动态的，实际上底层是静态的，是通过resize()操作去解决容量问题的。而链表则是一种真正的动态数据结构，它是这么一种数据结构，我们把数据存储在一个节点(Node)中，一个节点一般包含两部分的内容，一个是存储的数据，一个是它要指向的下一个节点

class Node {
    private E e;
    private Node next;
}

一个节点指向一个节点，所以最后看起来就像是一个链，我们把这种数据结构称为链表

最后一个节点的下一个节点为NULL，表示后面没有节点了。它是一个真正的动态的数据结构，不需要处理容量的问题。但是它也有缺点，它没有数组那样快的查询能力，它要查询某个节点的数据，只能通过头结点一直寻找下来(后面我们将看到)，所以它的查询速度比数组慢。

链表实现

现在我们将实现这么一个结构，首先设计好节点类

public class LinkedList<E> {
    //我们将Node设置为LinkedList的私有内部类
    private class Node<E> {
        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();
        }
    }
}

我们要想向链表中添加(或其他操作)元素，不可避免的要遍历链表(因为链表不能通过索引访问，只能通过前面的节点找到后面的节点)，而要遍历链表，我们就要将链表的头存储起来，这样才能遍历链表，我们将链表的头称为head

同时我们使用变量size来记录链表中元素的个数

public class LinkedList<E> {
    //为了节省篇幅，Node类不再展示，下同

    //头结点
    private Node head;
    //链表中元素的个数
    private int size;

    public LinkedList() {
        head = null;
        size = 0;
    }
}

现在我们实现两个简单的方法getSize()和isEmpty()

public int getSize() {
    return size;
}
public boolean isEmpty() {
    return size == 0;
}

添加元素

向链表头添加元素

首先将要插入的新节点指向head，然后将head设置为新节点，实现如下

public void addFirst(E e) {
    //体会一下这条语句的意思
    head = new Node(e,head);
    size++;
}

在链表的中间添加一个元素

比如现在往节点1后面插入一个元素，首先将新节点指向节点2，然后节点1指向新节点，实现如下

public void add(int index, E e) {
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("参数错误");
    }
    //如果是头结点需要单独处理
    if (index == 0) {
        addFirst(e);
    }
    //prev代表要插入位置的前一个节点
    Node prev = head;
    for (int i = 0; i < index - 1; i++) {
        prev = prev.next;
    }
    prev.next = new Node(e, prev.next);
    size++;
}

向链表的尾部添加一个元素

直接复用上面的代码

public void addLast(E e) {
    add(size, e);
}

虚拟头结点

我们在向链表中添加元素时，因为head前面没有节点，所以我们在添加元素时会对head进行单独的处理，为了不使head具有特殊性，我们在链表的最头部添加一个虚拟头结点，里面不存储元素，它的存在是为了使得操作链表方便

现在我们修改上面的head位dummyHead

public class LinkedList<E> {
    

    //虚拟结点
    private Node dummyHead;
    private int size;

    public LinkedList() {
        //这里修改了
        dummyHead = new Node(null, null);
        size = 0;
    }

    public int getSize() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }

    //直接调用add方法
    public void addFirst(E e) {
        add(0,e);
    }

    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("参数错误");
        }
		
        //不需要对head进行单独的处理了
        //index - 1修改为了index
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }

    public void addLast(E e) {
        add(size, e);
    }
}

获得某个索引的值

实现的思路同add很像，不过这里我们找的不是前一个节点，而是当前的节点

public E get(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("参数错误");
    }
    //cur代表当前节点
    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }
    return (E) cur.e;
}

基于这个方法，我们可以很快的实现getFirst()和getLast()

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

更新某个索引的值

实现的思路完全是同get()方法，直接上代码

public void set(int index, E e) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("参数错误");
    }
    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++) {
        cur = cur.next;
    }
    cur.e = e;
}

查找链表是否存在元素e

public boolean contains(E e) {
    //从当前节点开始，一直遍历到最后一个节点
    for (Node cur = dummyHead.next; cur != null; cur = cur.next) {
        if (cur.e.equals(e)) {
            return true;
        }
    }
    return false;
}

删除链表中的元素

上图已详细说明了操作的步骤，这里直接贴上代码实现

public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("参数错误");
    }
    
    //获得要删除节点的前一个节点
    Node prev = dummyHead;
    for (int i = 0; i < index; i++) {
        prev = prev.next;
    }
    
    //图示的操作
    Node delNode = prev.next;
    prev.next = delNode.next;
    delNode.next = null;
    size--;
    return (E) delNode.e;
}

根据上面的方法，可以很快的实现removeFirst()和removeLast()方法

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

toString()

@Override
public String toString() {
    StringBuilder res = new StringBuilder();
    
    Node cur = dummyHead.next;
    //你可以使用上面的for循环
    while (cur != null) {
        res.append(cur + "->");
        cur = cur.next;
    }
    res.append("NULL");
    
    return res.toString();
}

全部代码

public class LinkedList<E> {
    private class Node<E> {
        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(null, null);
        size = 0;
    }

    public int getSize() {
        return size;
    }
    public boolean isEmpty() {
        return size == 0;
    }

    public void addFirst(E e) {
        add(0,e);
    }

    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("参数错误");
        }

        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size++;
    }

    public void addLast(E e) {
        add(size, e);
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("参数错误");
        }

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

        return (E) cur.e;
    }

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

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

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

        cur.e = e;
    }

    public boolean contains(E e) {
        for (Node cur = dummyHead.next; cur != null; cur = cur.next) {
            if (cur.e.equals(e)) {
                return true;
            }
        }

        return false;
    }

    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("参数错误");
        }

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

        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;

        size--;

        return (E) delNode.e;
    }

    public E removeFirst() {
        return remove(0);
    }
    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();
    }
}

使用链表实现栈

由于链表的addFirst()和removeFirst()的操作都是O(1)，所以我们使用链表头作为栈顶，具体的实现逻辑如下

public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> linkedList;

    public LinkedListStack() {
        linkedList = new LinkedList<>();
    }

    @Override
    public void push(E e) {
        linkedList.addFirst(e);
    }

    @Override
    public E pop() {
        return linkedList.removeFirst();
    }

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

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public E peek() {
        return linkedList.getFirst();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack: top ");
        res.append(linkedList);

        return res.toString();
    }
}

使用链表实现队列

我们之前使用数组实现队列，由于它的dequeue操作是O(n)级别的，所以我们使用front来标记队首，使用循环队列设计，同样的在链表中从链表尾部删除或增加元素都是O(n)级别的，为了解决这一个问题，我们决定在链表的尾部增加一个tail变量来标记，从而使得在尾部增加元素是O(1)级别的

另外考虑在尾部删除一个元素是O(1)的吗? 答案是不是。因为我们删除一个节点需要知道该节点的前一个节点，而知道tail节点是无法知道tail的前一个节点的，我们还是要遍历。所以我们在head端删除元素，在tail端添加元素，并且由于只涉及到头部和尾部的操作，所以我们也不需要添加虚拟头结点了

下面就是实现的代码

public class LinkedListQueue<E> implements Queue<E> {
    private class Node<E> {
        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 head;
    private Node tail;
    private int size;

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

    @Override
    public void enqueue(E e) {
        //队列为空时，tail和head都为null 添加元素后二者都指向第一个元素
        if (size == 0) {
            tail = new Node(e);
            head = tail;
        } else {
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;
    }

    @Override
    public E dequeue() {
        if (size == 0) {
            throw new IllegalArgumentException("队列为空");
        }

        Node delNode = head;
        head = head.next;
        delNode.next = null;

        size--;
        //如果队列为空了，此时tail指向的是delNode，此时应该让tail为null
        if (size == 0) {
            tail = null;
        }
        return (E) delNode.e;
    }

    @Override
    public E getFront() {
        if (head == null) {
            throw new IllegalArgumentException("队列为空");
        }

        return (E) head.e;
    }

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

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

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();

        res.append("Queue: front ");

        Node cur = head;
        while (cur != null) {
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL tail");

        return res.toString();
    }
}

来源：CSDN

作者：The_last_knight

链接：https://blog.csdn.net/The_last_knight/article/details/103596602