java自定义链表

首先是单向链表

package com.cyx.collection.com.cyx.list;

/**
 * 自定义单向链表
 * @param <T> 泛型变量
 */
public class MyNode<T> {

    private T data;//链中存储的数据

    private MyNode<T> next;//下一个链

    public MyNode(T data, MyNode<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public MyNode<T> getNext() {
        return next;
    }

    public void setNext(MyNode<T> next) {
        this.next = next;
    }
}

package com.cyx.collection.com.cyx.list;

public class MyNodeTest {

    public static void main(String[] args) {
        MyNode<String> first = new MyNode<>("第一个链",null);
        MyNode<String> second = new MyNode<>("第二个链",null);
        first.setNext(second);
        MyNode<String> third = new MyNode<>("第三个链",null);
        second.setNext(third);
        MyNode<String> fourth = new MyNode<>("第四个链",null);
        third.setNext(fourth);
        MyNode<String> nextNode = first;
        while(nextNode != null){
            System.out.println(nextNode.getData());
            nextNode = nextNode.getNext();
        }
        System.out.println("===================");
        MyNode<Integer> number4 = new MyNode<>(4,null);
        MyNode<Integer> number3 = new MyNode<>(3,number4);
        MyNode<Integer> number2 = new MyNode<>(2,number3);
        MyNode<Integer> number1 = new MyNode<>(1,number2);
        MyNode<Integer> next = number1;
        while(next != null){
            System.out.println(next.getData());
            next = next.getNext();
        }
    }

}

这是一个自定义单向链表，使用了泛型作为变量，单向链表需要的变量有data，存储数据，还有next，表示指向下一链，创建构造方法，和get和set方法，再创建一个Test测试类，之后创建对象时，赋值，再赋值让箭头指向下一个链表，最后创建头结点，遍历获取链的数据，同时依次把节点更改，让他能链接上。

自定义双向链表

package com.cyx.collection.com.cyx.list;

/**
 * 自定义双向链表
 * @param <T>
 */
public class DeNode<T> {

    private T data;//链中存储的数据

    private DeNode<T> prev;//前一个链

    private DeNode<T> next;//后一个链

    public DeNode(T data, DeNode<T> prev, DeNode<T> next) {
        this.data = data;
        this.prev = prev;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public DeNode<T> getPrev() {
        return prev;
    }

    public void setPrev(DeNode<T> prev) {
        this.prev = prev;
    }

    public DeNode<T> getNext() {
        return next;
    }

    public void setNext(DeNode<T> next) {
        this.next = next;
    }
}

package com.cyx.collection.com.cyx.list;

public class DeNodeTest {

    public static void main(String[] args) {
        DeNode<Integer> number1 = new DeNode<>(1,null,null);
        DeNode<Integer> number2 = new DeNode<>(2,number1,null);
        number1.setNext(number2);
        DeNode<Integer> number3 = new DeNode<>(3,number2,null);
        number2.setNext(number3);
        DeNode<Integer> number4 = new DeNode<>(4,number3,null);
        number3.setNext(number4);
        DeNode<Integer> nextNode = number1;
        while(nextNode!=null){
            System.out.println(nextNode.getData());
            nextNode = nextNode.getNext();
        }
        System.out.println("========================");
        DeNode<Integer> prevNode = number4;
        while (prevNode != null){
            System.out.println(prevNode.getData());
            prevNode = prevNode.getPrev();
        }
    }

}

这是一个自定义双向链表，使用了泛型作为变量，双向链表需要的变量有data存储数据，prev指向前一个链，next指向下一个链，它们互相配合，就可以实现双向链表互相获取数据。构造对象时，赋值，按照上面代码，number1头结点，下一个链指向number2，number2上一个指向number1，下一个指向number3，number3上一个指向number2，下一个指向number4依次类推，接下来通过分别从前和后开始遍历，来从前和后开始打印元素。如何从前或后遍历呢?把number1赋值nextNode表示从number1开始，元素不为空，打印数据，之后把当前的下一个链，赋值给nextNode,依次循环，从前往后打印，从后往前打印呢？就是把最后一个元素当作头结点，开始遍历不为空，依次往前遍历。

讲的比较菜，(⊙﹏⊙)大家多体谅