Related Articles
Program for Least Recently Used (LRU) Page Replacement algorithm
• Difficulty Level : Medium
• Last Updated : 02 Sep, 2020

Prerequisite: Page Replacement Algorithms

In operating systems that use paging for memory management, page replacement algorithm are needed to decide which page needed to be replaced when new page comes in. Whenever a new page is referred and not present in memory, page fault occurs and Operating System replaces one of the existing pages with newly needed page. Different page replacement algorithms suggest different ways to decide which page to replace. The target for all algorithms is to reduce number of page faults.

In Least Recently Used (LRU) algorithm is a Greedy algorithm where the page to be replaced is least recently used. The idea is based on locality of reference, the least recently used page is not likely

Let say the page reference string 7 0 1 2 0 3 0 4 2 3 0 3 2 . Initially we have 4 page slots empty.
Initially all slots are empty, so when 7 0 1 2 are allocated to the empty slots —> 4 Page faults
0 is already their so —> 0 Page fault.
when 3 came it will take the place of 7 because it is least recently used —>1 Page fault
0 is already in memory so —> 0 Page fault.
4 will takes place of 1 —> 1 Page Fault
Now for the further page reference string —> 0 Page fault because they are already available in the memory. Given memory capacity (as number of pages it can hold) and a string representing pages to be referred, write a function to find number of page faults.

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

```Let capacity be the number of pages that
memory can hold.  Let set be the current
set of pages in memory.

1- Start traversing the pages.
i) If set holds less pages than capacity.
a) Insert page into the set one by one until
the size  of set reaches capacity or all
page requests are processed.
b) Simultaneously maintain the recent occurred
index of each page in a map called indexes.
c) Increment page fault
ii) Else
If current page is present in set, do nothing.
Else
a) Find the page in the set that was least
recently used. We find it using index array.
We basically need to replace the page with
minimum index.
b) Replace the found page with current page.
c) Increment page faults.
d) Update index of current page.

2. Return page faults.
```

Below is implementation of above steps.

## C++

 `//C++ implementation of above algorithm``#include``using` `namespace` `std;`` ` `// Function to find page faults using indexes``int` `pageFaults(``int` `pages[], ``int` `n, ``int` `capacity)``{``    ``// To represent set of current pages. We use``    ``// an unordered_set so that we quickly check``    ``// if a page is present in set or not``    ``unordered_set<``int``> s;`` ` `    ``// To store least recently used indexes``    ``// of pages.``    ``unordered_map<``int``, ``int``> indexes;`` ` `    ``// Start from initial page``    ``int` `page_faults = 0;``    ``for` `(``int` `i=0; i

## Java

 `// Java implementation of above algorithm`` ` `import` `java.util.HashMap;``import` `java.util.HashSet;``import` `java.util.Iterator;`` ` `class` `Test``{``    ``// Method to find page faults using indexes``    ``static` `int` `pageFaults(``int` `pages[], ``int` `n, ``int` `capacity)``    ``{``        ``// To represent set of current pages. We use``        ``// an unordered_set so that we quickly check``        ``// if a page is present in set or not``        ``HashSet s = ``new` `HashSet<>(capacity);``      ` `        ``// To store least recently used indexes``        ``// of pages.``        ``HashMap indexes = ``new` `HashMap<>();``      ` `        ``// Start from initial page``        ``int` `page_faults = ``0``;``        ``for` `(``int` `i=``0``; i itr = s.iterator();``                     ` `                    ``while` `(itr.hasNext()) {``                        ``int` `temp = itr.next();``                        ``if` `(indexes.get(temp) < lru)``                        ``{``                            ``lru = indexes.get(temp);``                            ``val = temp;``                        ``}``                    ``}``                 ` `                    ``// Remove the indexes page``                    ``s.remove(val);``                   ``//remove lru from hashmap``                   ``indexes.remove(val);``                    ``// insert the current page``                    ``s.add(pages[i]);``      ` `                    ``// Increment page faults``                    ``page_faults++;``                ``}``      ` `                ``// Update the current page index``                ``indexes.put(pages[i], i);``            ``}``        ``}``      ` `        ``return` `page_faults;``    ``}``     ` `    ``// Driver method``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `pages[] = {``7``, ``0``, ``1``, ``2``, ``0``, ``3``, ``0``, ``4``, ``2``, ``3``, ``0``, ``3``, ``2``};``        ` `        ``int` `capacity = ``4``;``         ` `        ``System.out.println(pageFaults(pages, pages.length, capacity));``    ``}``}``// This code is contributed by Gaurav Miglani`

## C#

 `// C# implementation of above algorithm``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG``{``    ``// Method to find page faults ``    ``// using indexes``    ``static` `int` `pageFaults(``int` `[]pages, ``                   ``int` `n, ``int` `capacity)``    ``{``        ``// To represent set of current pages. ``        ``// We use an unordered_set so that ``        ``// we quickly check if a page is ``        ``// present in set or not``        ``HashSet<``int``> s = ``new` `HashSet<``int``>(capacity);``     ` `        ``// To store least recently used indexes``        ``// of pages.``        ``Dictionary<``int``, ``                   ``int``> indexes = ``new` `Dictionary<``int``,``                                                 ``int``>();``     ` `        ``// Start from initial page``        ``int` `page_faults = 0;``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``// Check if the set can hold more pages``            ``if` `(s.Count < capacity)``            ``{``                ``// Insert it into set if not present``                ``// already which represents page fault``                ``if` `(!s.Contains(pages[i]))``                ``{``                    ``s.Add(pages[i]);``     ` `                    ``// increment page fault``                    ``page_faults++;``                ``}``     ` `                ``// Store the recently used index of``                ``// each page``                ``if``(indexes.ContainsKey(pages[i]))``                    ``indexes[pages[i]] = i;``                ``else``                    ``indexes.Add(pages[i], i);``            ``}``     ` `            ``// If the set is full then need to ``            ``// perform lru i.e. remove the least ``            ``// recently used page and insert``            ``// the current page``            ``else``            ``{``                ``// Check if current page is not ``                ``// already present in the set``                ``if` `(!s.Contains(pages[i]))``                ``{``                    ``// Find the least recently used pages``                    ``// that is present in the set``                    ``int` `lru = ``int``.MaxValue, val = ``int``.MinValue;``                                         ` `                    ``foreach` `(``int` `itr ``in` `s) ``                    ``{``                        ``int` `temp = itr;``                        ``if` `(indexes[temp] < lru)``                        ``{``                            ``lru = indexes[temp];``                            ``val = temp;``                        ``}``                    ``}``                 ` `                    ``// Remove the indexes page``                    ``s.Remove(val);``                     ` `                    ``//remove lru from hashmap``                    ``indexes.Remove(val);``                     ` `                    ``// insert the current page``                    ``s.Add(pages[i]);``     ` `                    ``// Increment page faults``                    ``page_faults++;``                ``}``     ` `                ``// Update the current page index``                ``if``(indexes.ContainsKey(pages[i]))``                    ``indexes[pages[i]] = i;``                ``else``                    ``indexes.Add(pages[i], i);``            ``}``        ``}``        ``return` `page_faults;``    ``}``     ` `    ``// Driver Code``    ``public` `static` `void` `Main(String []args)``    ``{``        ``int` `[]pages = {7, 0, 1, 2, 0, 3, ``                       ``0, 4, 2, 3, 0, 3, 2};``         ` `        ``int` `capacity = 4;``         ` `        ``Console.WriteLine(pageFaults(pages, ``                          ``pages.Length, capacity));``    ``}``}`` ` `// This code is contributed by 29AjayKumar`

Output:
```6
```

Another approach: (Without using HashMap)

## Java

 `// Java program for page replacement algorithms``import` `java.util.ArrayList;`` ` `public` `class` `LRU {``     ` `    ``// Driver method``    ``public` `static` `void` `main(String[] args) {``        ``int` `capacity = ``4``;``        ``int` `arr[] = {``7``, ``0``, ``1``, ``2``, ``0``, ``3``, ``0``, ``4``, ``2``, ``3``, ``0``, ``3``, ``2``};``         ` `        ``// To represent set of current pages.We use``        ``// an Arraylist``        ``ArrayList s=``new` `ArrayList<>(capacity);``        ``int` `count=``0``;``        ``int` `page_faults=``0``;``        ``for``(``int` `i:arr)``        ``{``            ``// Insert it into set if not present``            ``// already which represents page fault``            ``if``(!s.contains(i))``            ``{``             ` `            ``// Check if the set can hold equal pages``            ``if``(s.size()==capacity)``            ``{``                ``s.remove(``0``);``                ``s.add(capacity-``1``,i);``            ``}``            ``else``                ``s.add(count,i);``                ``// Increment page faults``                ``page_faults++;``                ``++count;``         ` `            ``}``            ``else``            ``{``                ``// Remove the indexes page``                ``s.remove((Object)i);``                ``// insert the current page``                ``s.add(s.size(),i);         ``            ``}``         ` `        ``}``        ``System.out.println(page_faults);``    ``}``}`

## Python3

 `# Python3 program for page replacement algorithm`` ` `# Driver code``capacity ``=` `4` `processList ``=` `[ ``7``, ``0``, ``1``, ``2``, ``0``, ``3``, ``0``,``                ``4``, ``2``, ``3``, ``0``, ``3``, ``2``]``                 ` `# List of current pages in Main Memory``s ``=` `[] `` ` `pageFaults ``=` `0``# pageHits = 0`` ` `for` `i ``in` `processList:`` ` `    ``# If i is not present in currentPages list``    ``if` `i ``not` `in` `s:`` ` `        ``# Check if the list can hold equal pages``        ``if``(``len``(s) ``=``=` `capacity):``            ``s.remove(s[``0``])``            ``s.append(i)`` ` `        ``else``:``            ``s.append(i)`` ` `        ``# Increment Page faults``        ``pageFaults ``+``=``1`` ` `    ``# If page is already there in ``    ``# currentPages i.e in Main``    ``else``:``         ` `        ``# Remove previous index of current page``        ``s.remove(i)`` ` `        ``# Now append it, at last index``        ``s.append(i)``     ` `print``(``"{}"``.``format``(pageFaults))`` ` `# This code is contributed by mahi_07`

## C#

 `// C# program for page replacement algorithms ``using` `System;``using` `System.Collections.Generic;`` ` `class` `LRU``{ ``     ` `    ``// Driver method ``    ``public` `static` `void` `Main(String[] args) ``    ``{ ``        ``int` `capacity = 4; ``        ``int` `[]arr = {7, 0, 1, 2, 0, 3, 0, ``                     ``4, 2, 3, 0, 3, 2}; ``         ` `        ``// To represent set of current pages.``        ``// We use an Arraylist ``        ``List<``int``> s = ``new` `List<``int``>(capacity); ``        ``int` `count = 0; ``        ``int` `page_faults = 0; ``        ``foreach``(``int` `i ``in` `arr) ``        ``{ ``            ``// Insert it into set if not present ``            ``// already which represents page fault ``            ``if``(!s.Contains(i)) ``            ``{ ``             ` `            ``// Check if the set can hold equal pages ``            ``if``(s.Count == capacity) ``            ``{ ``                ``s.RemoveAt(0); ``                ``s.Insert(capacity - 1, i); ``            ``} ``            ``else``                ``s.Insert(count, i); ``                 ` `                ``// Increment page faults ``                ``page_faults++; ``                ``++count; ``            ``} ``            ``else``            ``{ ``                ``// Remove the indexes page ``                ``s.Remove(i); ``                 ` `                ``// insert the current page ``                ``s.Insert(s.Count, i);         ``            ``} ``        ``} ``        ``Console.WriteLine(page_faults); ``    ``} ``} `` ` `// This code is contributed by Rajput-Ji`

Output:

```6
```

Note : We can also find the number of page hits. Just have to maintain a separate count.
If the current page is already in the memory then that must be count as Page-hit.

We will discuss other Page-replacement Algorithms in further sets.

This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.