【代码】java双向链表

package test;

import java.util.ArrayList;
import java.util.List;

public class Linked {
    public static void main(String[] args) {
        MyLinked myLinked = new MyLinked();


        myLinked.add(10);
        myLinked.add(20);
        myLinked.add(30);
        myLinked.add(40);
        myLinked.add(50);
        myLinked.add(60);
        myLinked.add(70);
        myLinked.add(80);
        myLinked.add(90);


        myLinked.delete(3);
        myLinked.println();

//        System.out.println(myLinked.getfist());
//        myLinked.half();

//        myLinked.reciprocal(2);

//        System.out.println(myLinked.size);

//        myLinked.delete(3);
//        myLinked.println();
//        MyLinked remove = myLinked.remove(3);
//        remove.println();
    }
}


//双向链表
class MyLinked {

    private Node first;
    private Node curr;
    public int size;

    

    /**
     * 节点中存储三个数据
     * prev是上一个节点的地址
     * next是下一个节点的地址
     * data是数据
     */
    class Node {
        private Node prev;
        private Node next;
        private int data;

        public Node() {

        }

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

    }


    //添加方法
    public void add(int data) {
        Node node = new Node(data);

        //首先判断第一个节点是否有值
        if (first == null) {
            first = node;
            curr = node;
        } else {
            //如果第一个节点有值的话
            //需要先将当前节点的next记录node的地址
            //再将node的prev记录当前节点的地址
            //再将当前节点替换成node
            curr.next = node;
            node.prev = curr;
            curr = node;
        }
        size++;
    }


    public void println() {
        Node node = first;
        List list = new ArrayList();

//        while (node != null) {
//            int value = node.data;
//            list.add(value);
//            node = node.prev;
//        }

        while (node != null) {
            int value = node.data;
            list.add(value);
            node = node.next;
        }

        System.out.println(list);

    }


    //取中间值
    public void half() {
        try {
            //中间值的话需要从第一个节点和最后一个节点往中间查找
            Node node = first;
            Node node1 = curr;
            //定义个依循环，当这两个节点相等则表示去到了中间节点
            while (node != node1) {
                //如果没有相等
                //就需要将头节点开始的下一个节点赋值给node
                //将尾节点的上一个节点赋值给node1
                node = node.next;
                node1 = node1.prev;
            }

            System.out.println(node.data);
        } catch (Exception e) {
            System.out.println("长度是偶数，无中间值");
        }
    }

    public int getfist() {
        return first.data;
    }


    //查找倒数第几个数据的话可以使用节点的上一个节点查找
    public void reciprocal(int K) {
        Node node = curr;
        int value = 0;
        for (int i = 0; i < K; i++) {
            value = node.data;
            node = node.prev;
        }

        System.out.println(value);
    }


//    public MyLinked remove(int index) {
//
//        MyLinked myLinked = new MyLinked();
//
//        Node node = first;
//
//        for (int i = 0; i < this.size; i++) {
//            int value = node.data;
//            node = node.next;
//            if ((i + 1) == index) {
//                continue;
//            }
//            myLinked.add(value);
//
//
//        }
//
//        return myLinked;
//    }


    //删除节点
    public void delete(int value) {
        /**
         * 删除节点的思路：
         * 需要一直查找到当前节点
         * 让后将当前节点的上一个节点的下一个节点修改成当前节点的下一个节点
         * 再将当前节点的下一个节点的上一个节点修改成当前节点的上一个节点
         */
        Node node = first;
        for (int i = 0; i < value - 1; i++) {
            node = node.next;
        }
        node.prev.next = node.next;
        node.next.prev = node.prev;

    }
}