数据结构之链表

目录

什么是链表

链表的基本操作

查找节点

更新节点

插入节点

删除节点

代码示例

---

什么是链表

如果说数组是数据结构界的行列整齐、纪律严明的“正规军”的话，那么链表就是数据结构界的秘密的、但却灵活多变的“地下党”。因为链表的结构很像“地下党”的这种单线联系的关系。

单向链表的结构如下：

链表（Linked List）是一种在物理上非连续、非顺序的顺序结构，由若干节点（Node）组成。单向链表的每一个节点又包含两个部分，一部分是存放数据的变量 data，一部分是存储指向下一个节点的指针 next。

public class Node{
    // 数据域
    int data;
    // 指针域
    Node next;
}

链表的第 1 个节点被称为头节点，最后 1 个节点称为尾节点，尾节点的 next 域指向空（null）。与数组按照下标来随即寻找元素不同，对于链表的其中一个节点 A，我们只能根据节点 A 的 next 指针来找到该节点的下一个节点 B，再根据节点 B 的 next 指针来找到下一个元素 C......这正如地下党的联系方式，一级一级，单线传递。

那么，通过链表的一个节点如何快速找到它的前一个节点呢？要想让每个节点都能回溯到它的前置节点，我们可以使用双向链表。那么什么是双向链表呢？双向链表比单向链表稍微复杂一点，它的每一个节点除了拥有存储数据域的 data 和指向下一个节点的 next 指针外，还拥有指向前一个节点的 prev 指针。

数组在内存中的存储方式是顺序存储，链表在内存中的存储方式则是随机存储。数组在内存中存储时占用了连续的完整的存储空间，而链表则采用了见缝插针的方式，链表的每一个节点分布在内存的不同位置，依靠 next 指针关联起来，这样可以灵活有效的利用零散的碎片空间。

链表的基本操作

查找节点

在查找元素时，链表不像数组那样可以通过下标快速定位元素，只能从头结点开始向后一个一个节点逐一查找。例如，需要查找一个链表的从头开始的第三个节点：

第 1 步，先将查找的指针定位到头节点；

第 2 步，根据头节点的 next 指针，定位到第 2 个节点；

第 3 步，根据第 2 个节点的 next 指针，定位到第 3 个节点，查找完毕。

由于链表中的数据只能按顺序进行访问，所以最坏的时间复杂度是。

更新节点

如果不考虑查找结点的过程，链表的更新过程会像数组那样简单，直接把旧数据替换成新数据即可，如：

插入节点

与数组类似，链表的插入节点操作，分为三种情况，即尾部插入、头部插入和中间插入。

尾部插入：最简单的一种链表节点插入的方式，即直接把最后一个节点的 next 指针指向待插入的新节点即可。

头部插入： 分为两个步骤。

第一步：把新节点的 next 指针指向原先的头节点；

第二步：把新节点变为链表的头节点。

中间插入： 分为两个步骤。

第一步：将新节点的 next 指针指向插入位置的节点；

第二步：将插入位置前置节点的 next 指针指向新节点。

只要内存空间允许，能够插入链表的元素是无穷无尽的，不需要像数组那样考虑扩容的问题。

删除节点

链表节点的删除操作同样分为三种情况，即尾部删除、头部删除和中间删除。

尾部删除：最简单的一种链表节点删除的情况，即直接把链表中倒数第二个节点的 next 指针指向空即可。

头部删除：与尾部删除类似，把链表的头节点置为原先链表的头节点的 next 指针即可。

中间删除：把待删除的节点的前一个节点的 next 指针指向待删除节点的 next 指针。

如果不考虑插入或删除之前的链表节点的查找操作的话，插入和删除节点的时间复杂度是。

代码示例

以上这些链表节点的查找、插入和删除操作的相关代码如下：

public class LinkedList {

    // 头节点
    private Node head;
    // 尾节点
    private Node last;
    // 链表容量
    private int size;

    private static class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
        }
    }

    /**
     * 链表节点的插入
     * @param data
     * @param index
     * @throws Exception
     */
    public void insertNode(int data, int index) {
        if (index < 0 || index > size) {
            System.out.println("插入节点时位置超出范围:" + index);
        }
        // 声明待插入节点
        Node insertNode = new Node(data);
        if (size == 0) {
            // 空链表
            System.out.println("链表为空,初始化链表元素为:" + data);
            head = insertNode;
            last = insertNode;
        } else if (index == 0) {
            System.out.println("头部插入,插入元素为:" + data);
            // 头部插入
            // 第一步：待插入节点的 next 指针指向头节点
            insertNode.next = head;
            // 更新头节点
            head = insertNode;
        } else if (index == size) {
            System.out.println("尾部插入,插入元素为:" + data);
            // 尾部插入
            // 第一步：尾节点的 next 指针指向待插入节点
            last.next = insertNode;
            // 更新尾节点
            last = insertNode;
        } else {
            System.out.println("中间插入,插入元素为:" + data);
            // 中间位置插入
            // 第一步：先获取到待插入节点的前置节点
            Node prevNode = getNode(index - 1);
            // 第二步：待插入节点的 next 指针指向前置节点的下一个节点
            insertNode.next = prevNode.next;
            // 第三步：前置节点的 next 指针指向待插入节点
            prevNode.next = insertNode;
        }
        size++;
        print();
    }

    /**
     * 删除节点
     * @param index
     * @return
     */
    public Node deleteNode(int index) {
        if (index < 0 || index > size) {
            System.out.println("删除节点时位置超出范围:" + index);
        }
        // 初始化待删除节点
        Node deleteNode = null;
        if (index == 0) {
            System.out.println("删除头节点:");
            // 删除头节点
            // 第一步：设置待删除结点为头节点
            deleteNode = head;
            // 第二步：将头节点指向头节点的下一个节点
            head = head.next;
        } else if(index == size) {
            System.out.println("删除尾节点:");
            // 删除尾节点
            // 第一步：获取到待删除节点的前置节点,即倒数第二个节点
            Node prevNode  = getNode(index - 1);
            // 第二步：指定待删除节点为尾节点
            deleteNode = prevNode.next;
            // 更新尾节点
            last = prevNode;
        } else {
            System.out.println("删除中间节点:");
            // 删除中间位置的节点
            // 第一步：获取到待删除结点的前置节点
            Node prevNode = getNode(index - 1);
            // 第二步：指定待删除节点的下一个节点为前置节点的 next 的 next
            Node nextNode = prevNode.next.next;
            // 第三步：将待删除节点指向前置节点的下一个节点
            deleteNode = prevNode.next;
            // 第四步：将前置节点的 next 指针指向待删除节点的下一个节点
            prevNode.next = nextNode;
        }
        size--;
        print();
        return deleteNode;
    }

    /**
     * 打印链表
     */
    public void print() {
        Node node = head;
        for (int i = 0; i < size - 1; i++) {
            System.out.print(node.data + " --> ");
            node = node.next;
        }
        System.out.println(node.data);
    }

    /**
     * 获取指点位置的链表节点
     * @param index
     * @return
     */
    public Node getNode(int index) {
        if (index == 0 || index > size) {
            System.out.println("获取链表元素位置超出范围:" + index);
        }
        Node node = head;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.insertNode(3, 0);
        linkedList.insertNode(7, 1);
        linkedList.insertNode(9, 2);
        linkedList.insertNode(5, 3);
        linkedList.insertNode(6, 4);
        linkedList.insertNode(4, 0);
        linkedList.insertNode(10, 5);

        linkedList.deleteNode(7);
        linkedList.deleteNode(0);
        linkedList.deleteNode(3);
    }

}