Posted on by Kalkicode
Code Hash

# Sort map by value in ascending order

Here given code implementation process.

``````/*
Java program
Sort map by value in ascending order
*/
import java.util.*;
public class SortElement
{
// Display map element
public void showMap(Map <Integer,Integer> mp)
{
// iterate map elements
for (int key: mp.keySet())
{
System.out.print("\n  "+key + "  :  " + mp.get(key));
}
}
// This function which is sort the map element by value
public <K, V extends Comparable<? super V>> Map<K, V> sortMapByValue(Map<K, V> map)
{
List< Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());

list.sort( Map.Entry.comparingByValue());

// Auxiliary map which is sort given map element
Map<K, V> auxiliary = new LinkedHashMap<>();

for (Map.Entry<K, V> entry : list)
{
// Add new key and value
auxiliary.put(entry.getKey(), entry.getValue());
}

return auxiliary;
}
public static void main(String[] args)
{

// Define map
Map <Integer,Integer> mp =  new HashMap <> ();
mp.put(1,7);
mp.put(2,7);
mp.put(3,3);
mp.put(4,-2);
mp.put(5,1);
mp.put(11,9);
System.out.print(" Before Sort : ");
// Show map element
System.out.print("\n After Sort : ");
// Show map elem
}
}``````

#### Output

`````` Before Sort :
1  :  7
2  :  7
3  :  3
4  :  -2
5  :  1
11  :  9
After Sort :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9``````
``````// Include header file
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;
/*
C++ program
Sort map by value in ascending order
*/
bool compare(pair < int, int > &i, pair < int, int > &j)
{
return (i.second < j.second);
}
// This function which is sort the map element by value
void sortMapByValue(map < int, int > &mp)
{
cout << " Before Sort : ";
for (auto &it: mp)
{
cout << "\n  " << it.first << "  :  " << it.second;
}
// Use vector to sort map element
vector < pair < int, int >> auxiliary;
// Add map elements into vector
for (auto &it: mp)
{
auxiliary.push_back(it);
}
// Sort using comparator function
sort(auxiliary.begin(), auxiliary.end(), compare);
cout << "\n After Sort : ";
for (auto &it: auxiliary)
{
cout << "\n  " << it.first << "  :  " << it.second;
}
}
int main()
{
// Define map
map < int, int > mp;
mp[1] = 7;
mp[2] = 7;
mp[3] = 3;
mp[4] = -2;
mp[5] = 1;
mp[11] = 9;
sortMapByValue(mp);
return 0;
}``````

#### Output

`````` Before Sort :
1  :  7
2  :  7
3  :  3
4  :  -2
5  :  1
11  :  9
After Sort :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9``````
``````// Include namespace system
using System;
using System.Linq;
using System.Collections.Generic;
/*
C# program
Sort dictionary by value in ascending order
*/
public class SortElement
{

public static void Main(String[] args)
{

// Define map
Dictionary < int, int > dict = new Dictionary <int, int> ();
Console.Write(" Before Sort Dictionary by value : \n");
//  Display calculated result
foreach(KeyValuePair < int, int > entry in dict)
{
Console.WriteLine("  " + entry.Key + "  :  " + entry.Value);
}
// Show map element
Console.Write(" Sorted Dictionary by value : \n");
//  Display calculated result
foreach(KeyValuePair < int, int > entry in dict.OrderBy(key => key.Value))
{
Console.WriteLine("  " + entry.Key + "  :  " + entry.Value);
}
}
}``````

#### Output

`````` Before Sort Dictionary by value :
1  :  7
2  :  7
3  :  3
4  :  -2
5  :  1
11  :  9
Sorted Dictionary by value :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9``````
``````class SortElement
{
// Display map element
showMap(mp)
{
//Display result
for (let [key, value] of mp.entries())
{
console.log("  "+ key + "  :  " + value);
}
}
}

function main()
{
// Define map
var mp = new Map();
mp.set(1, 7);
mp.set(2, 7);
mp.set(3, 3);
mp.set(4, -2);
mp.set(5, 1);
mp.set(11, 9);
process.stdout.write(" Before Sort : \n");
// Show map element
mp = new Map([...mp.entries()].sort((a, b) => a[1] > b[1]));
process.stdout.write("\n After Sort : \n");
// Show map elem
}
main();``````

#### Output

`````` Before Sort :
1  :  7
2  :  7
3  :  3
4  :  -2
5  :  1
11  :  9

After Sort :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9``````
``````# Sort dict by value in ascending order
def main() :

#  Define dict
dict_item = dict()
dict_item[1] = 7
dict_item[2] = 7
dict_item[3] = 3
dict_item[4] = -2
dict_item[5] = 1
dict_item[11] = 9
print(" Before Sort : ", end = "")
print(dict_item)
result = sorted(dict_item.items(), key = lambda v:(v[1], v[0]))
print("\n Sorted : ", end = "")
print(result)

if __name__ == "__main__": main()``````

#### Output

`````` Before Sort : {1: 7, 2: 7, 3: 3, 4: -2, 5: 1, 11: 9}

Sorted : [(4, -2), (5, 1), (3, 3), (1, 7), (2, 7), (11, 9)]``````
``````class SortElement
#  Display Hash element
def showMap(mp)
mp.each{ |key,value|  puts "   #{key}  :  #{value}" }
end

end

def main()
#  Define Hash
mp = Hash.new
mp[1] = 7
mp[2] = 7
mp[3] = 3
mp[4] = -2
mp[5] = 1
mp[11] = 9
print(" Before Sort : \n")
#  Show map element
mp = mp.sort_by {|_key, value| value}
print("\n After Sort : \n")
#  Show map elem
end

main()``````

#### Output

`````` Before Sort :
1  :  7
2  :  7
3  :  3
4  :  -2
5  :  1
11  :  9

After Sort :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9
``````
``````import scala.collection.immutable.ListMap;
/*
Scala program
Sort map by value in ascending order
*/
class SortElement
{
// Display map element
def showMap( mp : Map[Int, Int] ): Unit = {
mp.keys.foreach
{
key => println("  " + key + "  :  " + mp(key));
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: SortElement = new SortElement();
// Define map
var mp : Map[Int, Int] = Map();
mp  += (1->(7));
mp  += (2->(7));
mp  += (3->(3));
mp  += (4->(-2));
mp  += (5->(1));
mp  += (11->(9));
print(" Before Sort : \n");
// Show map element
val result = ListMap(mp.toSeq.sortBy(_._2):_*)
print("\n After Sort : \n");
// Show map elem
}
}``````

#### Output

`````` Before Sort :
5  :  1
1  :  7
2  :  7
3  :  3
11  :  9
4  :  -2

After Sort :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9``````
``````/*
Swift 4 program
Sort map by value in ascending order
*/

func main()
{
// Define dictionary
var dictItem = [Int: Int]();
dictItem[1] = 7;
dictItem[2] = 7;
dictItem[3] = 3;
dictItem[4] = -2;
dictItem[5] = 1;
dictItem[11] = 9;
print(" Before Sort : ");
for (key,value) in  dictItem
{
print("\(key) : \(value)")
}
let result = dictItem.sorted { \$0.1 < \$1.1 };
print("\n After Sort : ");
// Show dict element
for (key,value) in  result
{
print("\(key) : \(value)")
}

}
main();``````

#### Output

`````` Before Sort :
5 : 1
11 : 9
2 : 7
3 : 3
1 : 7
4 : -2

After Sort :
4 : -2
5 : 1
3 : 3
2 : 7
1 : 7
11 : 9``````
``````/*
Kotlin program
Sort map by value in ascending order
*/
class SortElement
{
// Display map element
fun showMap(mp: HashMap < Int, Int > ): Unit
{
for (key in mp.keys)
{
println("   " + key + "  :  " + mp[key]);
}
}
}
fun main(args: Array < String > ): Unit
{
// Define map
var mp = hashMapOf < Int , Int > ();
mp.put(1, 7);
mp.put(2, 7);
mp.put(3, 3);
mp.put(4, -2);
mp.put(5, 1);
mp.put(11, 9);
print(" Before Sort : \n");
// Show map element
var result = mp.toList().sortedBy { (_, value) -> value}.toMap()
print("\n After Sort : \n");
for (key in result.keys)
{
println("   " + key + "  :  " + mp[key]);
}
}``````

#### Output

`````` Before Sort :
1  :  7
2  :  7
3  :  3
4  :  -2
5  :  1
11  :  9

After Sort :
4  :  -2
5  :  1
3  :  3
1  :  7
2  :  7
11  :  9``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post