Java数据结构单链表实现

一，创建节点类

1，属性

value：节点中存储的值

next：节点中存储的下一个节点的地址

2，构造方法

节点中存储值和下一个节点的地址

class Node{
    // 存储值
    Object value;
    // 存储下一个节点的地址
    Node next;

    // 构造方法
    // 格式： 以类名为方法名，创建对象的时候执行，没有返回值结构
    public Node(E e, Node next){
        this.value = e;
        this.next = next;
    }
}

二，创建单链表类

1，属性

root：头结点

last：尾节点

size：链表大小

public class MyLinkedList {
    // 组成结构 节点
    // 声明头节点
    Node root;
    Node last;
    int size;
}

2，构造方法

传入第一个数

空值报错，不为空令为头结点，大小加1

public MyLinkedList(E e){
        if(e == null){
            throw new NullPointerException ("e：" + e);
        }
        root = new Node<> (e, null);
        size++;
    }

添加数据

头结点为空则令为头结点，不为空则循环迭代找到最后一个节点，连接在后面

public void addFor(E e){
        // 判断 root 是否为null
        if(root == null){
            root = new Node<> (e, null);
            size++;
            return;
        }
        // 循环查找 最后一个节点
        // 迭代的思路
        Node tempNode = root;
        while(tempNode.next != null){
            // 替换
            tempNode = tempNode.next;
        }
        System.out.println ("tempNode:" + tempNode);
        tempNode.next = new Node<> (e, null);

    }

头插法

头结点为空则令为头结点，不为空则连接在头结点前面，令为新的头结点

public void addFirst(E e){
        // 判断 root 是否为null
        if(root == null){
            root = new Node<> (e, null);
            size++;
            return;
        }
        // 头插法
        Node node = new Node<> (e, root);
        root = node;
    }

尾插法

头结点为空则令为头结点，不为空则接在尾节点后面令为新的尾节点，大小加1

public void addLast(E e){
        // 判断 root 是否为null
        if(root == null){
            root = new Node<> (e, null);
            size++;
            // 将当前节点设置为last节点
            return;
        }
        //尾插法
        last.next = new Node<> (e, null);
        last = last.next;
        size++;
    }

查找

通过循环迭代找到相等的元素返回true，没找到返回false

public boolean get(E e){
        Node tempNode = root;
        while(tempNode != null){
            if(tempNode.value == e){
                return true;
            }else{
                tempNode = tempNode.next;
            }
        }
        return false;
    }

删除

通过循环迭代找到需要删除的元素，让需要删除的节点值等于下一个节点的值，需要删除的节点的next等于下一个节点的后面的节点，删除成功返回true

public Object remove(E e){
        Node tempNode = root;
        while(tempNode != null) {
            if (tempNode.value == e) {
                tempNode.value = tempNode.next.value;
                tempNode.next = tempNode.next.next;
            }
            tempNode = tempNode.next;
        }
        return true;
    }

替换

通过循环迭代找到需要替换的值，更换value，成功返回true

public Object set(E e,E a){
        Node tempNode = root;
        while(tempNode != null) {
            if (tempNode.value == e) {
                tempNode.value = a;
            } else {
                tempNode = tempNode.next;
            }
        }
        return true;
    }

两个链表合并

通过循环迭代找到第一个链表的为节点，连接上第二个链表的头结点

public void addLinkList(Node head1,Node head2){
        Node tempNode = head1;
        while(tempNode.next != null){
            // 替换
            tempNode = tempNode.next;
        }
        System.out.println ("tempNode:" + tempNode);
        tempNode.next = head2;
    }

添加一个数组进链表

循环数组元素依次加入链表

public void addArray(Object[] ObjArr){
        for(int i =0;i< ObjArr.length;i++){
            addFor((E) ObjArr[i]);
        }
    }

输出链表元素

循环输出链表每个节点的元素

public void ForAll(Node head) {
        Node tempNode = head;
        while(tempNode.next != null){
            System.out.println (tempNode.value);
            tempNode = tempNode.next;
        }
    }

三，完整代码

class Node{
    // 存储值
    Object value;
    // 存储下一个节点的地址
    Node next;

    // 构造方法
    // 格式： 以类名为方法名，创建对象的时候执行，没有返回值结构
    public Node(E e, Node next){
        this.value = e;
        this.next = next;
    }

}

public class MyLinkedList {
    // 组成结构 节点
    // 声明头节点
    Node root;
    Node last;
    int size;

    public MyLinkedList(E e){
        if(e == null){
            throw new NullPointerException ("e：" + e);
        }
        root = new Node<> (e, null);
        size++;
    }

    // 添加数据
    public void addFor(E e){
        // 判断 root 是否为null
        if(root == null){
            root = new Node<> (e, null);
            size++;
            return;
        }
        // 循环查找 最后一个节点
        // 迭代的思路
        Node tempNode = root;
        while(tempNode.next != null){
            // 替换
            tempNode = tempNode.next;
        }
        System.out.println ("tempNode:" + tempNode);
        tempNode.next = new Node<> (e, null);

    }

    // 添加数据

    /**
     * 头插法
     * 每次添加进来的节点 都是 头节点
     *
     * @param e
     */
    public void addFirst(E e){
        // 判断 root 是否为null
        if(root == null){
            root = new Node<> (e, null);
            size++;
            return;
        }
        // 头插法
        Node node = new Node<> (e, root);
        root = node;
    }

    /**
     * 尾插法
     * 每次添加进来的节点 都是 尾节点
     *
     * @param e
     */
    public void addLast(E e){
        // 判断 root 是否为null
        if(root == null){
            root = new Node<> (e, null);
            size++;
            // 将当前节点设置为last节点
            return;
        }
        //尾插法
        last.next = new Node<> (e, null);
        last = last.next;
        size++;
    }
    /**
     * 查找
     */
    public boolean get(E e){
        Node tempNode = root;
        while(tempNode != null){
            if(tempNode.value == e){
                return true;
            }else{
                tempNode = tempNode.next;
            }
        }
        return false;
    }


    /**
     * 删除
     */
    public Object remove(E e){
        Node tempNode = root;
        while(tempNode != null) {
            if (tempNode.value == e) {
                tempNode.value = tempNode.next.value;
                tempNode.next = tempNode.next.next;
            }
            tempNode = tempNode.next;
        }
        return true;
    }

    /**
     * 替换
     */
    public Object set(E e,E a){
        Node tempNode = root;
        while(tempNode != null) {
            if (tempNode.value == e) {
                tempNode.value = a;
            } else {
                tempNode = tempNode.next;
            }
        }
        return true;
    }

    /**
     * 两个链表合并
     */
    public void addLinkList(Node head1,Node head2){
        Node tempNode = head1;
        while(tempNode.next != null){
            // 替换
            tempNode = tempNode.next;
        }
        System.out.println ("tempNode:" + tempNode);
        tempNode.next = head2;
    }

    /**
     * 添加一个数组到链表中
     */
    public void addArray(Object[] ObjArr){
        for(int i =0;i< ObjArr.length;i++){
            addFor((E) ObjArr[i]);
        }
    }

    public void ForAll(Node head) {
        Node tempNode = head;
        while(tempNode.next != null){
            System.out.println (tempNode.value);
            tempNode = tempNode.next;
        }
    }

    public static void main(String[] args){
        MyLinkedList myLinkList = new MyLinkedList<>();
        MyLinkedList myLinkList2 = new MyLinkedList<>();

        for(int i=1;i<11;i++){
            myLinkList.addFor(i);
        }
        myLinkList.ForAll(myLinkList.root);

        myLinkList.remove(5);

        myLinkList.ForAll(myLinkList.root);


        //for(int i=11;i<21;i++){
            //myLinkList2.addFor(i);
        //}
        //myLinkList.addLinkList(myLinkList.root,myLinkList2.root);

        //for(int i =1;i<21;i++){
            //System.out.println(myLinkList.get(i));
        //}
    }

}