[数据结构]-LinkedList

数据结构-LinkedList

---

前言

LinkedList历史
于1955-1956年，由兰德公司的Allen Newell、Cliff Shaw和Herbert A. Simon开发了链表，作为他们的信息处理语言的主要数据结构。链表的另一个早期出现是由 Hans Peter Luhn 在 1953 年 1 月编写的IBM内部备忘录建议在链式哈希表中使用链表。

到 1960 年代初，链表和使用这些结构作为主要数据表示的语言的实用性已经很好地建立起来。MIT 林肯实验室的 Bert Green于 1961 年 3 月在 IRE Transactions on Human Factors in Electronics 上发表了一篇题为“用于符号操作的计算机语言”的评论文章，总结了链表方法的优点。1964 年 4 月，Bobrow 和 Raphael 的一篇评论文章“列表处理计算机语言的比较”发表在 ACM 通讯中。

---

一、链表数据结构

在计算机科学中，链表是数据元素的线性集合，元素的线性顺序不是由它们在内存中的物理地址给出的。它是由一组节点组成的数据结构，每个元素指向下一个元素，这些节点一起，表示线性序列。

在最简单的链表结构下，链表的每个结点由一个指针(指向下一个元素)和数据项构成，链表允许在迭代时有效地从任意位置插入或删除元素。

链表的数据结构通过链的连接方式，提供了可以不需要扩容空间就更高效的插入和删除元素的操作，在适合的场景下它是一种非常方便的数据结构。但在一些需要遍历、指定位置操作、或者访问任意元素下，是需要循环遍历的，这将导致时间复杂度的提升。

二、链表分类

链表的主要表现形式分为；单向链表、双向链表、循环链表。

1. 单向链表

单链表中的每个Node结点由数据项和指向下一个Node结点的指针构成。可以对单链表执行的操作包括插入、删除和遍历。

2.双向链表

在双向链表中，每个Node结点除了又指向下一个结点的 next 指针外，还有指向前一个结点的 prev 指针，当然结点中还有数据项。

3.循环链表

在链表中，通常来讲最后一个结点的 next 指针会置空，标识着这个链表已经到达末尾，但当链表中最后一个结点的 next 指针指向 Head 结点时，我们将这种链表称为循环链表。 当然这三类只是最基本的链接类型，还有诸如双向循环链表等，这种结构其实就是双向链表和循环链表的组合，这里不再赘诉。

---

三、链表的实现

public class LinkedList<E> implements List<E> {
	 /**
     * ？表示不确定的 java 类型
     * T (type) 表示具体的一个java类型
     * K V (key value) 分别代表java键值中的Key Value
     * E (element) 代表Element
     */
    private static class Node<E> {

        E item;
        Node<E> next;
        Node<E> prev;

        public Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }

    }

    transient int size = 0;

    transient Node<E> first;

    transient Node<E> last;

    public LinkedList() {
    }

    void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
    }

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
    }

    @Override
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    @Override
    public boolean addFirst(E e) {
        linkFirst(e);
        return true;
    }

    @Override
    public boolean addLast(E e) {
        linkLast(e);
        return true;
    }

    @Override
    public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

    E unlink(Node<E> x) {
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        return element;
    }


    @Override
    public E get(int index) {
        return node(index).item;
    }

    @Override
    public void printLinkList() {
        if (this.size == 0) {
            System.out.println("链表为空");
        } else {
            Node<E> temp = first;
            System.out.print("目前的列表，头节点：" + first.item + " 尾节点：" + last.item + " 整体：");
            while (temp != null) {
                System.out.print(temp.item + "，");
                temp = temp.next;
            }
            System.out.println();
        }
    }

    Node<E> node(int index) {
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

总结

关于 LinkedList 常见的一些面试题：

1.描述一下链表的数据结构？
链表是由一组称为结点的对象组成的，每一个节点都分为两个部分：数据元素和指针。
链表中的节点通过指针连接起来，形成有序的数据序列。链表就好像一串珠子：数据元素是珠子的大小或形状。

2.Java 中 LinkedList 使用的是单向链表、双向链表还是循环链表？
Java 中 Linklist 是双向循环链表。

3.链表中数据的插入、删除、获取元素，时间复杂度是多少？
链表中数据的插入和删除时间复杂度是 O(1)，获取元素的时间复杂度是 O(n)。

4.什么场景下使用链表更合适？
适合需要频繁插入和删除的操作，不确定数据量。不适用于频繁访问元素，因为其时间复杂度是O(n)。