数据结构——链表（插入&删除）

链表

与顺序表相比链表最大的区别是其元素不是在连续的内存空间上。

用Node类来表示：

public class Node {
    public int val;  // 元素
    public Node next;  //  指向下一结点的位置

    public Node(int val){
        this.val = val;
    }
}

下面我们先来建立一条链表：

public class Main {

    public static Node createList(){
        Node a = new Node(1);
        Node b = new Node(2);
        Node c = new Node(3);
        Node d = new Node(4);
        a.next = b;
        b.next = c;
        c.next = d;
        return a;
    }
}

用图示描述这条链表：（假设地址）

插入

1. 插入到链表末尾：

    public static void insertTail(Node head, int val){
        if (head == null){
            return;
        }
        Node cur = head;
        while (cur.next != null){
            cur = cur.next;
        }
        Node newNode = new Node(val);
        cur.next = newNode;
    }
    public static void main(String[] args) {
        Node head = createList();
        // 尾插 100
        insertTail(head,100);
        print(head);  // 打印的方法
    }

遍历链表找到最后一个结点，将结点 cur 的 next 指向 newNode。

ps:遍历打印的方法：

    public static void print(Node head){
        for (Node cur = head; cur != null; cur = cur.next){
            System.out.print( " " + cur.val);
        }
    }

2. 插入到链表头部：

    public static void main(String[] args) {
        Node head = createList();
        Node newNode = new Node(100);
        newNode.next = head;
        head = newNode;
        print(head);  // 打印的方法
    }

图示：

head 原本存放的是 0x100 的地址，现将 newNode 的 next 指向 head（即 newNode 的下一结点的位置为 0x100 ），然后再改变 head 为 newNode（即现在 head 地址是 0x800 ），再返回 head ，打印则可发现 newNode 在链表首部。
结果：

3. 插入到链表中间：

这里拿插入到 1 和 2 之间为示例：

    public static void main(String[] args) {
        Node head = createList();
        // 把节点插入到 1 和 2 之间
        Node prev = head;
        Node newNode = new Node(100);
        newNode.next = prev.next;
        prev.next = newNode;
        print(prev);
  }

注意这里的（1）（2）步骤不能改变顺序，否则将会变成 prev.next 指向 newNode, newNode.next 指向 prev.next，也就还是指向 newNode。

删除

删除一般结点：

1. 按照值删除结点：

    // 按值删除结点
    public static void remove(Node head, int val){
        Node prev = head;
        while (prev != null
                && prev.next != null
                && prev.next.val != val){
            prev = prev.next;
        }

        if (prev == null || prev.next == null){
            return;
        }
        prev.next = prev.next.next;
    }
    // 测试：
    public static void main(String[] args) {    
            // 删除值为 2 的结点
        Node head = createList();
        remove(head,2);
        print(head);
    }

2. 按照位置删除结点：

	// 按照位置删除结点
    public static void remove(Node head, Node toDelete){
        Node prev = head;
        while (prev != null && prev.next != toDelete){
            prev = prev.next;
        }
        if (prev == null){
            return;
        }
        prev.next = toDelete.next;
    }
        // 删除位置第2版 （但无法删除最后末尾结点）
    public static void remove2(Node head, Node toDelete){
        Node nextNode = toDelete.next;
        toDelete.val = nextNode.val;
        toDelete.next = nextNode.next;
    }
    public static void main(String[] args) {    
        // 删除 tmp 结点
        Node head = createList();
        Node tmp = head.next;
        remove(head,tmp);
        print(head);
    }
    

跟按值删除结点类似。

删除头结点：
只需要修改 head 的指向即可

    public static void main(String[] args) {    
        // 删除头结点
        Node head = createList();
        if(head == null){
        	throw new RuntimeException("链表为空");
        }
        head = head.next;        
        print(head);
    }

链表这块刚开始学对我来说确实好痛苦，一不小心就乱了，还是得多练，弄不懂就多画图。
文章有不足之处还请指正，感谢 ❥(･ω･)ﾉ~~