笔试题(LRU)算法之JAVA实现

操作系统中可以使用LRU(Least Recently Used)内存淘汰旧数据的策略,如果内存需要加载新数据但空间不足,则会按照最近访问时间进行排序,并将最老的数据淘汰。假设现在内存空间大小为5,原本内存中没有数据,对内存中数据的访问顺序如下:1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 问访问过程中发生缺页的次数是多少次?

JAVA实现:
首先实现一个固定长度的集合队列

  1. package com.itstyle.list;
  2. import java.util.Collection;
  3. import java.util.Iterator;
  4. import java.util.LinkedList;
  5. import java.util.Queue;
  6. /**
  7. * 实现一个固定长度的集合队列
  8. * 在开发中,有时候我们会遇到这样的需求:
  9. * 对一个集合操作,提前为集合指定最大大小,在我们不断向集合中添加数据的时候,当数据内容超过最大值的时候,自动将最先入队的元素移除队列。
  10. * @param <E>
  11. */
  12. public class LimitQueue<E> implements Queue<E> {
  13. /**
  14. * 队列长度,实例化类的时候指定
  15. */
  16. private int limit;
  17. Queue<E> queue = new LinkedList<E>();
  18. public LimitQueue(int limit){
  19. this.limit = limit;
  20. }
  21. /**
  22. * 入队
  23. */
  24. @Override
  25. public boolean offer(E e){
  26. if(queue.size() >= limit){
  27. //如果超出长度,入队时,先出队
  28. queue.poll();
  29. }
  30. return queue.offer(e);
  31. }
  32. /**
  33. * 出队
  34. */
  35. @Override
  36. public E poll() {
  37. return queue.poll();
  38. }
  39. /**
  40. * 获取队列
  41. */
  42. public Queue<E> getQueue(){
  43. return queue;
  44. }
  45. /**
  46. * 获取限制大小
  47. */
  48. public int getLimit(){
  49. return limit;
  50. }
  51. @Override
  52. public boolean add(E e) {
  53. return queue.add(e);
  54. }
  55. @Override
  56. public E element() {
  57. return queue.element();
  58. }
  59. @Override
  60. public E peek() {
  61. return queue.peek();
  62. }
  63. @Override
  64. public boolean isEmpty() {
  65. return queue.size() == 0 ? true : false;
  66. }
  67. @Override
  68. public int size() {
  69. return queue.size();
  70. }
  71. @Override
  72. public E remove() {
  73. return queue.remove();
  74. }
  75. @Override
  76. public boolean addAll(Collection<? extends E> c) {
  77. return queue.addAll(c);
  78. }
  79. @Override
  80. public void clear() {
  81. queue.clear();
  82. }
  83. @Override
  84. public boolean contains(Object o) {
  85. return queue.contains(o);
  86. }
  87. @Override
  88. public boolean containsAll(Collection<?> c) {
  89. return queue.containsAll(c);
  90. }
  91. @Override
  92. public Iterator<E> iterator() {
  93. return queue.iterator();
  94. }
  95. @Override
  96. public boolean remove(Object o) {
  97. return queue.remove(o);
  98. }
  99. @Override
  100. public boolean removeAll(Collection<?> c) {
  101. return queue.removeAll(c);
  102. }
  103. @Override
  104. public boolean retainAll(Collection<?> c) {
  105. return queue.retainAll(c);
  106. }
  107. @Override
  108. public Object[] toArray() {
  109. return queue.toArray();
  110. }
  111. @Override
  112. public <T> T[] toArray(T[] a) {
  113. return queue.toArray(a);
  114. }
  115. }

执行方法:

  1. package com.itstyle.list;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. /**
  5. * 操作系统中可以使用LRU(Least Recently Used)内存淘汰旧数据的策略,如果内存需要加载新数据但空间不足,
  6. * 则会按照最近访问时间进行排序,并将最老的数据淘汰。假设现在内存空间大小为5,原本内存中没有数据,对内存中数据的访问顺序如下:
  7. * 1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 问访问过程中发生缺页的次数是多少次?
  8. *
  9. */
  10. public class LRU {
  11. public static void main(String[] args) {
  12. LimitQueue<String> list = new LimitQueue<String>(5);
  13. Integer[] array = new Integer[]{1, 2, 5, 3, 4, 6,1, 4, 3, 6, 7, 8, 3, 9 };
  14. List<Integer> page = new ArrayList<Integer>();
  15. for(Integer i :array){
  16. if(list.contains(i.toString())){
  17. list.remove(i);
  18. }else{
  19. page.add(i);
  20. }
  21. list.offer(i.toString());
  22. }
  23. System.out.println("缺页数量"+page.size()+",缺页数据"+page.toString());
  24. }
  25. }
点赞