数据结构学习之链表篇(Java)

链表–真正的动态数据结构
前面实现的线性数据结构:动态数组，栈，队列底层依托静态数组，靠resize函数解决固定容量问题。不算是真正的动态数据结构。
为什么链表很重要：

• 最简单的动态数据结构
• 更深入理解引用（或者指针）
• 更深入的理解递归
• 辅助组成其他数据结构

链表(Linked List)
数据存储在一种单独的结构中，这种结构通常成为"节点"(Node)。
优点：真正的动态，不需要处理固定容量的问题
缺点：丧失了随机访问的能力
所以链表不适合用于索引有语义的情况

单向链表的基本实现(增删改查):

/**
 * @author ymn
 * @version 1.0
 * @date 2020\4\13 0013 13:40
 */
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 = e;
            this.next = null;
        }

        public Node() {
            this.e = null;
            this.next = 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;
    }
    //O(1)
    public void addFirst(E e){
        add(0,e);
    }
    //在链表的index(0-based)位置添加新的元素e
    //在链表中不是一个常用的操作,练习用
    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;
            }
            Node node = new Node(e);
            node.next = prev.next;
            prev.next = node;
//          prev.next = new Node(e,prev.next)
            size ++;
    }
    //在链表末尾添加元素e
    public void addLast(E e){
        add(size,e);
    }
    // 获得链表的第index(0-based)个位置的元素
    //在链表中不是一个常用的操作,练习用
    public E get(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Add failed,Illegal index");
        }
        Node cur = dummyHead.next;
        for (int i =0;i < index; i++){
            cur = cur.next;
        }
        return cur.e;
    }
    //获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }
    //获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }
    //修改第index位置的元素为e
    public void set(int index,E e){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Add failed,Illegal index");
        }
        Node cur = dummyHead.next;
        for (int i =0;i < index; i++){
            cur = cur.next;
        }
        cur.e = e;
    }
    //查询链表中是否包含元素e
    public boolean contains(E e){
        //思路就是遍历链表中的元素然后与e进行比较
        Node cur = dummyHead.next;
        while (cur != null){
            if (cur.e.equals(e)){
                return true;
            }else {
                cur = cur.next;
            }
        }
        return false;
    }
    //删除在index位置的元素
    //在链表中不是常用的操作，练习用
    public E remove(int index){
        //先判断参数是否合法
        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;
        }
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        size --;

        return delNode.e;
    }
    //删除链表的头结点
    public E removeFirst(){
       return remove(0);
    }
    //删除链表的尾节点
    public E removeLast(){
        return remove(size - 1);
    }
    //重写toString方法
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        //遍历打印
        res.append("dummyHead ->");
        for (Node cur = dummyHead.next; cur != null; cur = cur.next){
            res.append(cur+"->");
        }
        res.append("NUll");
        return res.toString();
    }
}

带有尾指针的链表（用链表实现队列）:

import java.util.NoSuchElementException;

/**
 * @author ymn
 * @version 1.0 带有尾指针的链表（用链表实现队列）
 * @date 2020\4\14 0014 15:59
 */
public class LinkedListQueue<T> implements Queue<T> {

    private class Node{
        public T e;
        public Node next;

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

        public Node() {
            this.e = null;
            this.next = 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(T e) {
       if (tail == null){
           tail = new Node(e);
           head = tail;
       }else {
           tail.next = new Node(e);
           tail = tail.next;
       }
       size ++;
    }

    @Override
    public T dequeue() {
        if (isEmpty()){
            throw new NoSuchElementException("Cannot dequeue from an empty queue");
        }
        Node delNode = head;
        head = head.next;
        delNode.next = null;
        if (head == null){
            tail = null;
        }
        return delNode.e;
    }

    @Override
    public T getFront() {
        return null;
    }
}

实现栈的接口使用链表实现栈：

/**
 * @author ymn
 * @version 1.0
 * @date 2020\4\14 0014 15:30
 */
public class LinkedListStack<T> implements Stack<T> {
    private LinkedList<T> linkedList;

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

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

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

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

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

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

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