单链表实现LRU淘汰算法

这里是引用

import java.util.Scanner;



/*
思路：
单链表知识点：
用单链表实现lru最少最远使用淘汰策略
 least recently used

首先单链表定义 ：
有数据data
有后指针 也叫引用 node.next

所以定义一个单链表定义方法是啥 ：


SingleNode  :

private T element ; （泛型对象 因为不知道data是啥 ）
private SingleNode next ; （后指针）

单链表对象定义完了后 ，一个类应该拥有对象以及方法  。

单链表的方法 ：

1、创建一个单链表
需要定义容量大小 ，当元素的个数小于容量大小时，只需要将新进的元素加到链表的首位即可 。
新访问的元素 链表中已经满了的话  需要将链表的最后一位删除 然后将新的元素插入到头节点

需要开发的方法有 ：
1、寻找头节点方法
2、添加方法 分链表容量满了跟没满两个逻辑。
3、新进来的数据在链表中存在需要删除改元素后，将该元素添加至链表首位。
4、链表容量满了之后 需要将链表尾节点删除

 */
public class LruTest<T> {
    /*
    头节点
     */
    private SingleNode<T> headNode;
    //定义默认单链表最大长度是5；
    private final static Integer Default_Capacity = 5;
    //获取链表长度
    private Integer length;
    //获取链表容量
    private Integer capacity;

    //构造方法
    // 构建一个空的单链表
    public LruTest() {
        //最大容量为5
        this.capacity = Default_Capacity;
        this.headNode = new SingleNode<>();
        this.length = 0;
    }

    //添加 删除操作

    public void add(T data) {
        //首先判断该数据在单链表中得位置 ，存在还是不存在
        SingleNode preNode = findPreNode(data);
        if (preNode != null) {
            //如果存在该数据需要将该节点删除
            deleteTargetNode(preNode);
            //将该节点放到首节点去
            insertTargetNodeonHead(data);
        } else {
            //单链表中元素都塞满了 新元素进来得加到头 然后最后一位删除；
            if (length >= this.capacity) {
                deleteEndNode();
            }
            //将该节点放到首节点后面
            insertTargetNodeonHead(data);

        }
    }

    private void deleteEndNode() {
        SingleNode node = headNode;
        //空链表直接返回
        if (node.getNext() == null) {
            return;
        }
        //找出最后一个节点的前面的那个元素
        //让其指针指向null即可实现删除最后一位元素
        while (node.getNext().getNext() != null) {
            //当该元素的next的next不为空证明是倒数第三个
            //获取到他的后一个也就是倒数第二个了
            node = node.getNext();
        }
        //不用创建新对象然后赋值null了
        SingleNode temp = node.getNext();
        //关键就是让这个node指向null就删了
        node.setNext(null);
        temp = null;
        length--;
    }

    private void insertTargetNodeonHead(T data) {
        //找到首节点得next 然后让next指向data
        SingleNode next = headNode.getNext();
        headNode.setNext(new SingleNode(data, next));
        //添加进元素后需要链表长度+1；
        length++;
    }

    private void deleteTargetNode(SingleNode preNode) {
        //获取到的是该节点的前一个节点；首先获取到前节点的next
        SingleNode temp = preNode.getNext();
        //将前节点的
        preNode.setNext(temp.next);
        //删除需要长度减一
        length--;
    }

    //获取到该元素得前一个节点
    public SingleNode findPreNode(T data) {
        //获取该单链表的头节点
        SingleNode node = headNode;
        //遍历该链表 直到最后一个节点
        while (node.getNext() != null) {
            //如果该数据等于这个节点得下一个节点得数据，那么就证明
            //此节点是要找得前一个节点
            if (data.equals(node.getNext().getElement())) {
                return node;
            }
            //去找下一个节点继续遍历
            node = node.getNext();
        }
        return null;

    }

    private void printAllElement() {
        SingleNode node = headNode.getNext();
        while (node != null) {
            System.out.print(node.getElement() + ",");
            node = node.getNext();
        }
        System.out.println();
    }


    private class SingleNode<T> {
        private T element;
        private SingleNode next;

        public SingleNode(T element, SingleNode next) {
            this.element = element;
            this.next = next;
        }

        public SingleNode() {
            this.next = null;
        }

        public T getElement() {
            return element;
        }

        public void setElement(T element) {
            this.element = element;
        }

        public SingleNode getNext() {
            return next;
        }

        public void setNext(SingleNode next) {
            this.next = next;
        }


    }

    public static void main(String[] args) {
        LruTest list = new LruTest();
        Scanner in = new Scanner(System.in);
        while (true) {
            list.add(in.nextInt());
            list.printAllElement();
        }
    }
}