Java链表（1）

🐵本篇文章将对单链表进行讲解，模拟实现单链表中常见的方法

---

一、什么是链表

链表是一种逻辑结构上连续而物理结构上不一定连续的线性表，链表由一个一个节点组成：

每一个节点中都由数据域（val）和指针域（next）组成，数据域用于存放要存放在该节点的数据，指针域用于存放节点的地址，上图中链表的每一个节点的指针域存放的是下一个节点的地址，最后一个节点的指针指向空

二、链表的种类

链表细分可以分为八种，分别为：

1. 单向不带头非循环链表 2. 单向不带头循环链表 

3. 单向带头非循环链表     4. 单向带头循环链表

5. 双向不带头非循环链表 6. 双向不带头循环链表 

7. 单向带头非循环链表     8. 双向带头循环链表

三、链表的模拟实现

首先对第一种单链表的增删查改等操作用Java进行模拟实现，先将要模拟实现的方法写到IList接口中：

public interface IList {
    //头插法
    public void addFirst(int data);

    //尾插法
    public void addLast(int data);

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);

    //查找关键字key是否在单链表当中
    public boolean contains(int key);

    //删除第一次出现关键字为key的节点
    public void remove(int key);

    //删除所有值为key的节点
    public void removeAllKey(int key);

    //得到单链表的长度
    public int size();

    //清空链表
    public void clear();

    //遍历并展示链表中的数据
    public void display();
}

之后再创建一个MySingleList类实现上述接口并重写接口中所有的方法

public class MySingleList implements IList{
    static class ListNode {
        public int val;
        public ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head; //指向第一个节点
    
    /*以下是要重写IList接口中的方法*/
    ...

}

在MySingleList类中创建一个静态内部类ListNode用于描述一个节点对象，val用于存放数据，next用于存放下一个节点的地址，构造方法用于初始化数据va，接下来对上述方法进行模拟实现

3.1 方法的实现

public void addFirst(int data);

在链表的头部新增一个节点newNode

很明显要在头部新增一个节点就应让newNode的next指向head，并让newNode成为head

    public void addFirst(int data) {
        ListNode newNode = new ListNode(data);
        newNode.next = head;
        head = newNode;
    }

---

public void addLast(int data);

在链表的尾部新增一个节点

应让最后一个节点的next引用指向newNode，链表无法像顺序表一样可以直接找到某个位置的节点，所以应该通过循环先找到最后一个节点：

ListNode cur = head; //通常一个链表的头指针不动，需要定义一个cur来遍历链表、

while (cur.next != null) {
    cur = cur.next; //只要cur的next不是空，cur就指向下一个节点
}

//循环完成后cur就是最后一个节点
cur.next = newNode; 

完成以上操作后还要考虑一个特殊情况：如果链表为空，上述代码能否完成尾插操作？答案是不能的，因为如果链表为空，则head为空，cur为空，在循环条件处cur.next != null就会抛出一个NullPointerException的空指针异常，所以要单独处理链表为空的情况：

    public void addLast(int data) {
        ListNode newNode = new ListNode(data);
        if (head == null) { //如果链表为空，则直接让head指向newNode
            head = newNode;
        } else {
            ListNode cur = head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = newNode;
        }
    }

---

public int size();

求链表的长度也就是该链表有几个节点，只要直接遍历链表即可

    public int size() {
        ListNode cur = head;
        int count = 0;
        while(cur != null) { //注意这里和尾插的循环条件不一样
            count++;
            cur = cur.next;
        }

        return count;
    }

---

public boolean contains(int key);

判断链表中是否有节点的val值等于key，也是只要直接遍历链表即可

    public boolean contains(int key) {
        ListNode cur = head;
        while(cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

---

public void addIndex(int index,int data);

在任意位置处插入一个节点，第一个节点的索引为0

首先要判断一下index是否合法：

public class IndexException extends RuntimeException{
    public IndexException(String message) {
        super(message);
    }
}

=======================================================

public void addIndex(int index, int data) {
    if (index < 0 || index > size()) {
        throw new IndexException("下标错误");
    }
    ...
}

在任意位置插入节点，所以如果index为0或等于链表长度，就可以直接使用刚刚实现过的头插和尾插方法

public void addIndex(int index, int data) {
    if (index < 0 || index > size()) {
        throw new IndexException("下标错误");
    }
    if (index == 0) {
        addFirst(data);
    }
    if (index == size()) {
        addLast(data);
    }

    ...
}

然后就是一般情况下：

如果要在1位置处插入新节点，那就应该先找到1位置处的节点的前驱节点，这里定义为cur，令newNode.next = cur.next;这样newNode的next就指向1位置处的节点，之后令cur.next = newNode这样就插入完成了

    public void addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            throw new IndexException("下标错误");
        }
        if (index == 0) {
            addFirst(data);
        }
        if (index == size()) {
            addLast(data);
        }

        ListNode newNode = new ListNode(data);
        ListNode cur = head;

        for (int i = 0; i < index - 1; i++) { 找到插入节点的前驱节点
            cur = cur.next;
        }

        newNode.next = cur.next;
        cur.next = newNode;
    }

---

public void remove(int key);

假如要删除val = 20的节点（这里先定义为del）如果要删除该节点就应让del的前驱节点的next指向del的后继节点：

    public void remove(int key) {
        ListNode cur = head;

        while(cur.next.val != key) { //通过循环找到del的前驱节点
            cur = cur.next; 
        }
        cur.next = cur.next.next;
    }

写完后还要考虑两种特殊情况：

第一，如果链表为空，上述代码不能满足要求，因为在循环条件处会抛出空指针异常

第二，如果要删除的节点是第一个节点，上述代码也不能满足要求，因为该循环是从第一个节点的下一个节点开始判断的

以上两种情况都需要单独处理：

    public void remove(int key) {
        if (head == null) {
            return;
        }
        if (head.val == key) {
            head = head.next;
            return;
        }
        ListNode cur = head;
        while(cur.next.val != key) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
    }

---

public void removeAllKey(int key);

删除所有val = key的节点，那就需要遍历整个链表，在遍历过程中删除节点：

    public void removeAllKey(int key) {

        ListNode cur = head;
        while (cur.next != null) {
            if(cur.next.val == key) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }

    }

在循环的结束也要判断一下第一个节点是否为要删除的节点，因为上述循环条件为cur.next != null没有判断第一个节点：

    public void removeAllKey(int key) {
        if (head == null) { //如果链表为空则直接返回
            return;
        }

        ListNode cur = head;
        while (cur.next != null) {
            if(cur.next.val == key) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        if (head.val == key) {
            head = head.next;
        }
    }

---

public void clear();

清空链表，由于对象在没有被引用时，就会自动被回收，所以只需要将head置为空就行了

public void clear() {
    head = null;
}

---

🙉本篇文章到此结束，下篇文章将对LinkedList类进行讲解