一 面试经典：

        1. 如何设计一个LRU缓存淘汰算法？基础

        思想：新加的点来了， 首先去链表里面遍历，如果找到了。删掉 然后插入到头部。头部就是最新的吧如果不在原来的链表里:如果有空间就插入头部。LRU有内存限制的，如果没有空间了怎么办? 删除最后一个，完成了这个算法!

（ 最近使用，只需要维护一个有序的单链表就可以了。有序的指的就是加入的时间排序 ）

        2. 约瑟夫问题  （对手娟，丢到谁谁淘汰，只留最后一个人）

       二 什么是链表？

        1.链表的定义

        链表通过指针将一组零散的内存块串联在一起。其中，我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要记录链上的下一个结点的地址。

        2.特点
                (1)不需要连续的内存空间。
                (2)有指针引用
                (3)三种最常见的链表结构：单链表、双向链表和循环链表

        单向链表说明：

        从单链表图中，可以发现，有两个结点是比较特殊的，它们分别是第一个结点和最后一个结点。我们一般把第一个结点叫作头结点，把最后一个结点叫作尾结点。
其中，头结点用来记录链表的基地址。有了它，我们就可以遍历得到整条链表。而尾结点特殊的地方是：指针不是指向下一个结点，而是指向一个空地址NULL，表示这是链表上最后一个结点。while(p.next != null){} head 自己记录的

          循环链表说明：

        循环链表是一种特殊的单链表。实际上，循环链表也很简单。它跟单链表唯一的区别就在尾结点。我们知道，单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点。从我画的循环链表图中，你应该可以看出来，它像一个环一样首尾相连，所以叫作“循环”链表。

      三 代码实现单链表和双向链表

package list;

/**
 * @author:Kevin
 * @create: 2023-08-14 10:45
 * @Description:        单向列表
 */

public class MyLinkedList {

    private ListNode head;
    private int size = 0;

    public void insertHead(int data){    //插入链表头部    O（1）
        ListNode newNode = new ListNode(data);

        newNode.next = head;
        head = newNode;

    }

    public void inertNth(int data,int postion){        //插入链表中间位置   O（n）
        if (postion == 0){
            insertHead(data);
        }else {
            ListNode cur = head;
            for (int i = 1;i<postion;i++){
                cur = cur.next;
            }
            ListNode listNode = new ListNode(data);

            listNode.next = cur.next;
            cur.next = listNode;
        }

    }

    public void deleteHead(){   //O(1)

        head = head.next;

    }

    public void deleteNth(int position){    //O（n）

        if (position == 0){
            deleteHead();
        }else {
            ListNode cur = head;
            for (int i =1;i<position;i++){
                cur = cur.next;
            }
            cur.next=cur.next.next;
        }

    }

    public void print(){

        ListNode cur = head;
        while (cur!=null){
            System.out.println(cur.value);
            cur = cur.next;
        }

    }



}

class ListNode{

    int value;  //值
    ListNode next;  //指针

    ListNode(int value) {
        this.value = value;
        this.next = null;
    }
}

                双向链表

package list;

/**
 * 	双向列表
 */
public class DoubleLinkList {		// 双向链表

	private DNode head;		//头 
	private DNode tail;		// 尾
	
	DoubleLinkList(){
		head = null;
		tail = null;
	}
	
	public void inserHead(int data){
		DNode newNode = new DNode(data);
		if(head == null){
			tail = newNode;
		}else{
			head.pre = newNode;
			newNode.next = head;
		}
		head = newNode;
	}
	public void deleteHead(){
		if(head == null) return ;		//没有数据
		if(head.next == null){		//就一个点
			tail = null;
		}else{
			head.next.pre = null;	
		}
		head = head.next;
	}

	public void deleteKey(int data){
		DNode current = head;
		while (current.value != data) {
			if (current.next == null) {
				System.out.println("没找到节点");
				return ;
			}
			current = current.next;
		}
		if (current == head) {// 指向下个就表示删除第一个
			deleteHead();
		} else {
			current.pre.next = current.next;
			if(current == tail){		//删除的是尾部
				tail = current.pre;
				current.pre = null;
			}else{
				current.next.pre = current.pre;
			}
		}
	}
}

class DNode{
	
	int value;		//值
	DNode next;		//下一个的指针
	DNode pre;		//指向的是前一个指针

	DNode(int value){
		this.value = value;
		this.next = null;
		this.pre = null;
	}
}

     四 数组vs链表

重要区别：
        1.数组简单易用，在实现上使用的是连续的内存空间，可以借助CPU的缓存机制，预读数组中的数据，所以访问效率更高。
        2.链表在内存中并不是连续存储，所以对CPU缓存不友好，没办法有效预读。
        3.数组的缺点是大小固定，一经声明就要占用整块连续内存空间。如果声明的数组过大，系统可能没有足够的连续内存空间分配给它，
导致“内存不足（out ofmemory）”。如果声明的数组过小，则可能出现不够用的情况。
        4.动态扩容：数组需再申请一个更大的内存空间，把原数组拷贝进去，非常费时。链表本身没有大小的限制，天然地支持动态扩容。