自己编写-“单链表”

在数据结构中，我们所接触到的单链表，其实就是存入数据，并将每一个数据链接起来，所形成的一种存储结构。

我们在实际中接触的链表其实有很多种，这里我们以无头单向非循环链表来理解。先来了解一下单链表的结构吧。

单链表有很多节点构成，每个节点中存入的是该节点的值（data）以及下一个节点的地址（next），这样就将很多个节点连接起来了。看图片来理解吧！

data是想要存入的数据，next存入的是下一个节点的地址，在每个节点上面写的（100、200、300、400、500）是假设出的节点的地址。

1、构建节点

想要实现单链表的功能，先从0开始，我们需要有每个节点，才能去构造单链表。上面的结构中我们可以看出来，每个节点有data以及next。

Class Node {
	public int data;
	public Node next;
	
	public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

这里以整形为例，而存下一个节点的next指的是下一个结点，所以next就是Node类型。
2、这里需要注意，我们需要去定义一个头节点，也就是第一个节点，去代表这个链表。

public Node head;

3、头插法

public void addFirst(int data){
		//1、构造出这个节点
        Node node = new Node(data);
		//2、判断链表是否是空的，如果是就把头节点设为node。
        if(head == null) {
            head = node;
            return;
        }
        //3、正常头插时，需要将node的next与head连接，最后移动head的位置
        node.next = this.head;
        this.head = node;
    };

4、尾插法

：总体思路和头插法差不多

public void addLast(int data){
		//1、构建节点
        Node node = new Node(data);

		//2、判断是否是第一次
        if(head == null) {
            this.head = node;
            return;
        }
		//3、与头插法不同，我们需要先找到最后一个节点，所以我们定义一个cur让他循环走到链表最后，直接将其连接起来。
        Node cur = this.head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    };

5、任意位置插入

我们可以根据单链表的特征，我们可以找到一个节点的下一个，但不能找到上一个，所以我们想要在某个位置插入，就需要找到这个位置的上一个节点，直接连接就好。此时问题就转移到了如何去找上一个节点的问题。

//找上一个节点
private Node searchIndex(int index) {
		//1、先判断该位置的合法性
        if(index < 0 || index > this.size()) {
            throw new RuntimeException("index位置不合法");
        }
        //2、进行循环，定义一个节点，让其从第一个节点开始，向后移动。
        Node cur = this.head;
        while (index - 1 > 0) {
            cur = cur.next;
            index--;
        }
        //3、返回该节点
        return cur;
    }
    //任意位置插入
    public void addIndex(int index,int data){
    	//1、构造节点
        Node node = new Node(data);
        //2、如果是在1号位置插入，则就是头插法
        if(index == 1) {
            addFirst(data);
            return;
        }
        //3、如果是在链表长度的位置插入，就是尾插法
        if(index == this.size()) {
            addLast(data);
        }
		//4、接收index的上一个节点
        Node cur = searchIndex(index);
        //5、直接进行拼接就好。
        node.next = cur.next;
        cur.next = node;
    };

6、删除所有值为key的节点

我们在找到值为key的值之后直接将上一个节点连接到该值节点的下一个节点，但是我们是没有办法得知上一个节点的，所以我们需要定义一个节点去记录上一个节点的值，再定义一个节点去进行判断。如果与key相等，直接删除，并继续向后访问，否则就将两个定义的节点以此向后访问。这里就有一个问题，头节点的值如果等于key，如果我们刚开始就判断出来头节点需要删除，直接进行删除，那么头节点就会向后遍历，很容易出现问题，我们可以在判断完后面的值之后再判断head的值。

public void removeAllKey(int key) {
		//1、定义两个节点，cur为判断的点，prev始终是cur的前驱。
        Node cur = this.head.next;
        Node prev = this.head;
        while (cur != null) {
        //2、如果相等，直接将前驱prev的下一个节点设为cur的下一个节点，此时该节点已删除，cur向后移动
            if(cur.data == key) {
                prev.next = cur.next;
                cur = cur.next;
                //3、如果不等，cur和prev同时向后遍历。
            }else {
                prev = cur;
                cur = cur.next;
            }
        }
        //4、最后判断链表的头节点
        if(this.head.data == key) {
            this.head = this.head.next;
        }
    };

7、单链表的长度

public int size() {
		//1、定义一个链表从头向后移动
        Node cur = this.head;
		//2、如果头节点为空，说明该节点是空的
        if(head == null) {
            return -1;
        }
		//3、遍历所有链表，计算链表长度，每遍历一遍就将长度加1，访问完之后返回长度。
        int size = 0;
        while (cur != null) {
            size++;
            cur = cur.next;
        }
        return size;
    };