数据结构之手写单向链表

单向链表如下图所示：

 

 每个node节点都会指向下一个节点。这样的话，声明node变量的时候就需要有个next属性：

static class Node<T>{
        T data;
        Node<T> next;
        public Node(T data) {
            this.data = data;
        }
    }

类似上面的格式。

首先我们声明一个List，然后包含node属性，

class List<T> {
    static class Node<T>{
        T data;
        Node<T> next;
        public Node(T data) {
            this.data = data;
        }
    }
    Node<T> head = null;
}

head相当于当前的指针。如下图所示：

 

 插入方法：

如下图所示：

 

本来head指针是指向空的，也就是集合是个空的。现在插入新的元素后，指针就指向下一个空的。而添加的值赋予当前元素。类似数组添加一个，下标++一个道理。

    public void add(T data){
        Node<T> node = new Node<T>(data);
        node.next=head;
        head = node;
    }

查找就不细说了，这边用到了一个新断言，在课程上见到的。

public Node<T> find(Predicate<T> data){
        Node<T> n = this.head;
        while (n!=null){
            if(data.test(n.data)){
                return n;
            }
            n = n.next;
        }
        return null;
    }

// 查找测试方法

System.out.println(list.find(x->x==5));

删除元素：

因为包含重复元素，删除元素分为只删除第一个以及删除所有的，区别就在于全遍历或者查到就终止。这里只实现删除第一个。

如下图所示：删除元素node3，就是删除关联关系。

 

 就是更改next的关系。

所以代码实现如下：

public boolean removeFirst(Node<T> data){
        if(head==data){
            head = head.next;
            return true;
        }
        if(head==null){
            return true;
        }
        Node<T> prev = this.head;
        Node<T> next = this.head.next;
        while (next!=data && next!=null ){
            // 不匹配
            prev=next;
            next = next.next;
        }
        if(next!=null){
            // 匹配
            prev.next = next.next;
        }
        return true;
    }

如果删除的是第一个元素，则更改上一个元素的next就行。

如果删除的元素匹配则更改next指向关系。

如果不匹配关系则需要移动上一个元素和当前元素。因为删除当前元素需要更改上一个元素的next指向当前元素的下一个。所以要一起跳指针。

while (next!=data && next!=null ){
            // 不匹配
            prev=next;
            next = next.next;
        }

完整代码如下：

package com.example.demo;

import java.util.function.Predicate;

/*
 * 手写链表
 */
public class HandWriteList {


    public static void main(String[] args) {
        List<Integer> list = new List<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(5);
        list.add(4);
        list.add(4);
        list.add(10);
        list.add(8);

        System.out.println(list.removeFirst(list.find(x->x==4)));
//        System.out.println(list.find(x->x==5));


        List.Node n = list.head;
        while (n!=null){
            System.out.println(n.data);
            n = n.next;
        }

    }

}


class List<T> {
    static class Node<T>{
        T data;
        Node<T> next;
        public Node(T data) {
            this.data = data;
        }
    }
    Node<T> head = null;

    public void add(T data){
        Node<T> node = new Node<T>(data);
        node.next=head;
        head = node;
    }


    public Node<T> find(Predicate<T> data){
        Node<T> n = this.head;
        while (n!=null){
            if(data.test(n.data)){
                return n;
            }
            n = n.next;
        }
        return null;
    }



    public boolean removeFirst(Node<T> data){
        if(head==data){
            head = head.next;
            return true;
        }
        Node<T> prev = this.head;
        Node<T> next = this.head.next;
        while (next!=data && next!=null ){
            // 不匹配
            prev=next;
            next = next.next;
        }
        if(next!=null){
            // 匹配
            prev.next = next.next;
        }
        return true;
    }
}