转：LRU算法

时间 2019-12-08

标签 lru 算法繁體版

原文原文链接

LRU是Least Recently Used的缩写，即最近最少使用页面置换算法，是为虚拟页式存储管理服务的，是根据页面调入内存后的使用状况进行决策了。因为没法预测各页面未来的使用状况，只能利用“最近的过去”做为“最近的未来”的近似，所以，LRU算法就是将最近最久未使用的页面予以淘汰。java

能够用一个特殊的栈来保存当前正在使用的各个页面的页面号。当一个新的进程访问某页面时，便将该页面号压入栈顶，其余的页面号往栈底移，若是内存不够，则将栈底的页面号移除。这样，栈顶始终是最新被访问的页面的编号，而栈底则是最近最久未访问的页面的页面号。算法

如输入如下序列时：4,7,0,7,1,0,1,2,1,2,6数组

结果为：浏览器

4
4 7
4 7 0
4 0 7
4 0 7 1
4 7 1 0
4 7 0 1
4 7 0 1 2
4 7 0 2 1
4 7 0 1 2
7 0 1 2 6 数据结构

用Java代码实现LRU算法以下：spa

import java.util.ArrayList;  
import java.util.List;  
  
  
public class LRU {  
    /** 
     * 内存块的个数 
     */  
    public static final int N = 5;  
    /** 
     * 内存块数组 
     */  
    Object[] array = new Object[N];  
    private int size;  
      
    public LRU() {  
    }  
    /** 
     * 判断内存区是否为空 
     * @return 
     */  
    public boolean isEmpty() {  
        if(size == 0) {  
            return true;  
        } else {  
            return false;  
        }  
    }  
    /** 
     * 判断内存区是否达到最大值 
     * @return 
     */  
    public boolean isOutOfBoundary() {  
        if(size >=N) {  
            return true;  
        } else {  
            return false;  
        }  
    }  
    /** 
     * 查找元素o在数组中的位置 
     * @param o 
     * @return 
     */  
    public int indexOfElement(Object o) {  
        for(int i=0; i<N; i++) {   
            if(o == array[i]) {  
                return i;  
            }  
        }  
        return -1;  
    }     
    /** 
     * 有新的数据o须要申请内存 
     * @param o 
     * @return 移出内存区的数据 
     */  
    public Object push(Object o) {  
        int t = -1;  
        if(!isOutOfBoundary() && indexOfElement(o) == -1){  
            array[size] = o;  
            size ++;  
        } else if(isOutOfBoundary() && indexOfElement(o) == -1){  
            for(int i=0; i<size-1; i++) {  
                array[i] = array[i+1];                
            }  
            array[size-1] = o;  
        } else {  
            t = indexOfElement(o);  
            for(int i=t; i<size-1; i++) {  
                array[i] = array[i+1];  
            }  
            array[size-1] = o;  
        }  
        if( -1 == t) {  
            return null;  
        } else {  
            return array[t];  
        }  
    }  
    /** 
     * 输出内存区中的各数据 
     */  
    public void showMemoryBlock() {  
        for(int i=0; i<size; i++) {  
            System.out.print(array[i] + "\t");  
        }  
    }  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        Integer iter[] = {4,7,0,7,1,0,1,2,1,2,6};  
        LRU lru = new LRU();  
        for(int i=0; i<iter.length; i++) {  
            lru.push(iter[i]);  
            lru.showMemoryBlock();  
            System.out.println();  
        }  
    }  
  
}

LRU算法也能够用于一些实际的应用中，如你要作一个浏览器，或相似于淘宝客户端的应用的就要用到这个原理。你们都知道浏览器在浏览网页的时候会把下载的图片临时保存在本机的一个文件夹里，下次再访问时就会，直接从本机临时文件夹里读取。但保存图片的临时文件夹是有必定容量限制的，若是你浏览的网页太多，就会一些你最不常使用的图像删除掉，只保留最近最久使用的一些图片。这时就能够用到LRU算法了，这时上面算法里的这个特殊的栈就不是保存页面的序号了，而是每一个图片的序号或大小；因此上面这个栈的元素都用Object类来表示，这样的话这个栈就能够保存的对像了。.net