449 lines
15 KiB
Text
449 lines
15 KiB
Text
---
|
|
id: sorting-old
|
|
title: "Sorting with Custom Comparators Pt 1"
|
|
author: Darren Yao, Siyong Huang, Michael Cao, Benjamin Qi
|
|
prerequisites:
|
|
- Bronze - Pairs & Tuples in C++
|
|
- Bronze - Introduction to Data Structures
|
|
description: Both Java and C++ have built-in functions for sorting. However, if we use custom objects, or if we want to sort elements in a different order, then we'll need to use a custom comparator.
|
|
---
|
|
|
|
import { Problem } from "../models";
|
|
|
|
export const metadata = {
|
|
problems: {
|
|
sample: [
|
|
new Problem("Silver", "Wormhole Sort", "992", "Normal", false, [], ""),
|
|
],
|
|
general: [
|
|
new Problem("CSES", "Restaurant Customers", "1619", "Easy", false, [], "sort endpoints of intervals"),
|
|
new Problem("Silver", "Lifeguards", "786", "Easy", false, [], "sort endpoints of intervals"),
|
|
new Problem("Silver", "Rental Service", "787", "Easy", false, [], ""),
|
|
new Problem("Silver", "Mountains", "896", "Easy", false, [], ""),
|
|
new Problem("Silver", "Mooyo Mooyo", "860", "Easy", false, [], "Not a sorting problem, but you can use sorting to simulate gravity. - Write a custom comparator which puts zeroes at the front and use `stable_sort` to keep the relative order of other elements the same."),
|
|
new Problem("Silver", "Meetings", "967", "Very Hard", false, [], ""),
|
|
],
|
|
}
|
|
};
|
|
|
|
## Example: Wormhole Sort
|
|
|
|
<problems-list problems={metadata.problems.sample} />
|
|
|
|
There are multiple ways to solve this problem. We won't discuss the full solution here, but all of them start by sorting the edges in nondecreasing order of weight.
|
|
|
|
With C++, the easiest method is to use nested pairs.
|
|
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
|
|
#define f first
|
|
#define s second
|
|
|
|
int main() {
|
|
int M = 4;
|
|
vector<pair<int,pair<int,int>>> v;
|
|
for (int i = 0; i < M; ++i) {
|
|
int a,b,w; cin >> a >> b >> w;
|
|
v.push_back({w,{a,b}});
|
|
}
|
|
sort(begin(v),end(v));
|
|
for (auto e: v) cout << e.s.f << " " << e.s.s << " " << e.f << "\n";
|
|
}
|
|
```
|
|
|
|
But what if the built-in comparison function for pairs didn't exist?
|
|
|
|
- If we only stored the edge weights and sorted them, we would have a sorted list of edge weights, but it would be impossible to tell which weights corresponded to which edges.
|
|
- However, if we create a **class** (or struct) representing the edges and define a **custom comparator** to sort them by weight, we can sort the edges in ascending order while also keeping track of their endpoints.
|
|
|
|
|
|
## Classes
|
|
|
|
First, we need to define a **class** that represents what we want to sort (or a [`struct`](http://www.cplusplus.com/doc/tutorial/structures/) in C++, which is the same as a `class` in C++ but all members are public by default).
|
|
|
|
In our example we will define a class `Person` that contains a person's height and weight, and sort in ascending order by height.
|
|
|
|
```cpp
|
|
struct Person {
|
|
int height, weight;
|
|
Person (int h, int w) { height = h; weight = w; }
|
|
};
|
|
|
|
int main() {
|
|
Person p;
|
|
p.height = 60; // assigns 60 to the height of p
|
|
p.weight = 100; // assigns 100 to the weight of p
|
|
}
|
|
```
|
|
```java
|
|
static class Person {
|
|
int height, weight;
|
|
public Person (int h, int w) { height = h; weight = w; }
|
|
}
|
|
```
|
|
|
|
## Comparators
|
|
|
|
Normally, sorting functions rely on moving objects with a lower value in front of objects with a higher value if sorting in ascending order, and vice versa if in descending order. This is done through comparing two objects at a time.
|
|
|
|
### C++
|
|
|
|
<resources>
|
|
<resource source="CPH" title="3.2 - User-Defined Structs, Comparison Functions" starred></resource>
|
|
</resources>
|
|
|
|
What a comparator does is compare two objects as follows, based on our comparison criteria:
|
|
|
|
- If object $x$ is less than object $y$, return `true`
|
|
- If object $x$ is greater than or equal to object $y$, return `false`
|
|
|
|
Essentially, the comparator determines whether object $x$ belongs to the left of object $y$ in a sorted ordering. A comparator **must** return false for two identical objects (not doing so results in undefined behavior and potentially a runtime error).
|
|
|
|
In addition to returning the correct answer, comparators should also satisfy the following conditions:
|
|
|
|
- The function must be consistent with respect to reversing the order of the arguments: if $x \neq y$ and `compare(x, y)`is `true`, then `compare(y, x)` should be `false` and vice versa.
|
|
- The function must be transitive. If `compare(x, y)` is true and `compare(y, z)` is true, then `compare(x, z)` should also be true. If the first two compare functions both return `false`, the third must also return `false`.
|
|
|
|
### Java
|
|
|
|
What a `Comparator` does is compare two objects as follows, based on our comparison criteria:
|
|
|
|
- If object $x$ is less than object $y$, return a negative number.
|
|
- If object $x$ is greater than object $y$, return a positive number.
|
|
- If object $x$ is equal to object $y$, return 0.
|
|
|
|
In addition to returning the correct number, comparators should also satisfy the following conditions:
|
|
- The function must be consistent with respect to reversing the order of the arguments: if `compare(x, y)` is positive, then `compare(y, x)` should be negative and vice versa.
|
|
- The function must be transitive. If `compare(x, y) > 0` and `compare(y, z) > 0`, then `compare(x, z) > 0`. Same applies if the compare functions return negative numbers.
|
|
- Equality must be consistent. If `compare(x, y) = 0`, then `compare(x, z)` and `compare(y, z)` must both be positive, both negative, or both zero. Note that they don't have to be equal, they just need to have the same sign.
|
|
|
|
Java has default functions for comparing `int`, `long`, `double` types. The `Integer.compare()`, `Long.compare()`, and `Double.compare()` functions take two arguments $x$ and $y$ and compare them as described above.
|
|
|
|
## C++
|
|
|
|
<resources>
|
|
<resource source="fushar" title="Comparison Functions in C++" url="http://fusharblog.com/3-ways-to-define-comparison-functions-in-cpp/"></resource>
|
|
</resources>
|
|
|
|
### Method 1: Operator <
|
|
|
|
[StackOverflow: Why const T&?](https://stackoverflow.com/questions/11805322/why-should-i-use-const-t-instead-of-const-t-or-t)
|
|
|
|
- Pro:
|
|
- This is the easiest to implement
|
|
- Easy to work with STL
|
|
- Con:
|
|
- Only works for objects (not primitives)
|
|
- Only supports two types of comparisons (less than (<) and greater than (>))
|
|
|
|
<!-- Tested -->
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
int randint(int low, int high) {return low+rand()%(high-low);}
|
|
|
|
struct Foo
|
|
{
|
|
int Bar;
|
|
Foo(int _Bar=-1):Bar(_Bar){}
|
|
bool operator < (const Foo& foo2) const {return Bar < foo2.Bar;}
|
|
};
|
|
const int N = 8;
|
|
int main()
|
|
{
|
|
srand(69);
|
|
Foo a[N];
|
|
for(int i=0;i<N;++i) a[i] = Foo(randint(0, 20));
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
sort(a, a+N);
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
}
|
|
|
|
/**
|
|
Output:
|
|
(Foo: 3) (Foo: 18) (Foo: 13) (Foo: 5) (Foo: 18) (Foo: 3) (Foo: 15) (Foo: 0)
|
|
(Foo: 0) (Foo: 3) (Foo: 3) (Foo: 5) (Foo: 13) (Foo: 15) (Foo: 18) (Foo: 18)
|
|
*/
|
|
```
|
|
|
|
In the context of Wormhole Sort (uses [friend](https://www.geeksforgeeks.org/friend-class-function-cpp/)):
|
|
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
|
|
struct Edge {
|
|
int a,b,w;
|
|
friend bool operator<(const Edge& x, const Edge& y) { return x.w < y.w; }
|
|
}; // a different way to write less than
|
|
|
|
int main() {
|
|
int M = 4;
|
|
vector<Edge> v;
|
|
for (int i = 0; i < M; ++i) {
|
|
int a,b,w; cin >> a >> b >> w;
|
|
v.push_back({a,b,w});
|
|
}
|
|
sort(begin(v),end(v));
|
|
for (Edge e: v) cout << e.a << " " << e.b << " " << e.w << "\n";
|
|
}
|
|
|
|
/*
|
|
Input:
|
|
1 2 9
|
|
1 3 7
|
|
2 3 10
|
|
2 4 3
|
|
*/
|
|
|
|
/*
|
|
Output:
|
|
2 4 3
|
|
1 3 7
|
|
1 2 9
|
|
2 3 10
|
|
*/
|
|
```
|
|
|
|
### Method 2: Function Outside Class
|
|
|
|
Let's say we have an array `Person arr[N]`. To sort the array, we need to make custom comparator which will be a function, and then pass the function as a parameter into the build-in sort function:
|
|
|
|
```cpp
|
|
bool cmp(Person a, Person b) {
|
|
return a.height < b.height;
|
|
}
|
|
|
|
int main() {
|
|
sort(arr, arr+N, cmp); // sorts the array in ascending order by height
|
|
}
|
|
```
|
|
|
|
If we instead wanted to sort in descending order, this is also very simple. Instead of the `cmp` function returning `return a.height < b.height;`, it should do `return a.height > b.height;`.
|
|
|
|
- Pro:
|
|
- Works for both objects and primitives
|
|
- Supports many different comparators for the same object
|
|
- Con:
|
|
- More difficult to implement
|
|
- Extra care needs to be taken to support STL
|
|
|
|
We can also use [lambda expressions](https://www.geeksforgeeks.org/lambda-expression-in-c/) in C++11 or above.
|
|
|
|
<!-- Tested -->
|
|
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
int randint(int low, int high) {return low+rand()%(high-low);}
|
|
|
|
struct Foo
|
|
{
|
|
int Bar;
|
|
Foo(int _Bar=-1):Bar(_Bar){}
|
|
};
|
|
const int N = 8;
|
|
Foo a[N];
|
|
bool cmp1(Foo foo1, Foo foo2) {return foo1.Bar < foo2.Bar;}
|
|
function<bool(Foo,Foo)> cmp2 = [](Foo foo1, Foo foo2) {return foo1.Bar < foo2.Bar;}; // lambda expression
|
|
// bool(Foo,Foo) means that the function takes in two parameters of type Foo and returns bool
|
|
// "function<bool(Foo,Foo)>"" can be replaced with "auto"
|
|
|
|
int main()
|
|
{
|
|
srand(69);
|
|
|
|
printf("--- Method 1 ---\n");
|
|
for(int i=0;i<N;++i) a[i] = Foo(randint(0, 20));
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
sort(a, a+N, [](Foo foo1, Foo foo2){return foo1.Bar<foo2.Bar;}); // lambda expression
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
|
|
printf("--- Method 2 ---\n");
|
|
for(int i=0;i<N;++i) a[i] = Foo(randint(0, 20));
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
sort(a, a+N, cmp1);
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
|
|
printf("--- Method 3 ---\n");
|
|
for(int i=0;i<N;++i) a[i] = Foo(randint(0, 20));
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
sort(a, a+N, cmp2);
|
|
for(int i=0;i<N;++i) printf("(Foo: %2d) ", a[i].Bar); printf("\n");
|
|
}
|
|
```
|
|
|
|
Output:
|
|
|
|
```
|
|
--- Method 1 ---
|
|
(Foo: 3) (Foo: 18) (Foo: 13) (Foo: 5) (Foo: 18) (Foo: 3) (Foo: 15) (Foo: 0)
|
|
(Foo: 0) (Foo: 3) (Foo: 3) (Foo: 5) (Foo: 13) (Foo: 15) (Foo: 18) (Foo: 18)
|
|
--- Method 2 ---
|
|
(Foo: 5) (Foo: 13) (Foo: 18) (Foo: 0) (Foo: 9) (Foo: 4) (Foo: 2) (Foo: 15)
|
|
(Foo: 0) (Foo: 2) (Foo: 4) (Foo: 5) (Foo: 9) (Foo: 13) (Foo: 15) (Foo: 18)
|
|
--- Method 3 ---
|
|
(Foo: 1) (Foo: 1) (Foo: 18) (Foo: 0) (Foo: 11) (Foo: 12) (Foo: 1) (Foo: 5)
|
|
(Foo: 0) (Foo: 1) (Foo: 1) (Foo: 1) (Foo: 5) (Foo: 11) (Foo: 12) (Foo: 18)
|
|
```
|
|
|
|
In the context of Wormhole Sort:
|
|
|
|
```cpp
|
|
#include <bits/stdc++.h>
|
|
using namespace std;
|
|
|
|
struct Edge { int a,b,w; };
|
|
|
|
int main() {
|
|
int M = 4;
|
|
vector<Edge> v;
|
|
for (int i = 0; i < M; ++i) {
|
|
int a,b,w; cin >> a >> b >> w;
|
|
v.push_back({a,b,w});
|
|
}
|
|
sort(begin(v),end(v),[](const Edge& x, const Edge& y) { return x.w < y.w; });
|
|
for (Edge e: v) cout << e.a << " " << e.b << " " << e.w << "\n";
|
|
}
|
|
```
|
|
|
|
## Java
|
|
|
|
Now, there are two ways of implementing this in Java: `Comparable`, and `Comparator`. They essentially serve the same purpose, but `Comparable` is generally easier and shorter to code. `Comparable` is a function implemented within the class containing the custom object, while `Comparator` is its own class. For our example, we'll use a `Person` class that contains a person's height and weight, and sort in ascending order by height.
|
|
|
|
### Comparable
|
|
|
|
If we use `Comparable`, we'll need to put `implements Comparable<Person>` into the heading of the class. Furthermore, we'll need to implement the `compareTo` method. Essentially, `compareTo(x)` is the `compare` function that we described above, with the object itself as the first argument, or `compare(self, x)`.
|
|
|
|
```java
|
|
static class Person implements Comparable<Person>{
|
|
int height, weight;
|
|
public Person(int h, int w){
|
|
height = h; weight = w;
|
|
}
|
|
public int compareTo(Person p){
|
|
return Integer.compare(height, p.height);
|
|
}
|
|
}
|
|
```
|
|
|
|
When using Comparable, we can just call `Arrays.sort(arr)` or `Collections.sort(list)` on the array or list as usual.
|
|
|
|
### Comparator
|
|
|
|
If instead we choose to use `Comparator`, we'll need to declare a second `Comparator` class, and then implement that:
|
|
|
|
```java
|
|
static class Person{
|
|
int height, weight;
|
|
public Person(int h, int w){
|
|
height = h; weight = w;
|
|
}
|
|
}
|
|
static class Comp implements Comparator<Person>{
|
|
public int compare(Person a, Person b){
|
|
return Integer.compare(a.height, b.height);
|
|
}
|
|
}
|
|
```
|
|
|
|
When using `Comparator`, the syntax for using the built-in sorting function requires a second argument: `Arrays.sort(arr, new Comp())`, or `Collections.sort(list, new Comp())`.
|
|
|
|
If we instead wanted to sort in descending order, this is also very simple. Instead of the comparing function returning `Integer.compare(x, y)` of the arguments, it should instead return `-Integer.compare(x, y)`.
|
|
|
|
## Python
|
|
|
|
### Defining Operator
|
|
|
|
<!-- Tested -->
|
|
```py
|
|
import random
|
|
class Foo:
|
|
def __init__(self, _Bar): self.Bar = _Bar
|
|
def __str__(self): return "Foo({})".format(self.Bar)
|
|
def __lt__(self, o): # lt means less than
|
|
return self.Bar < o.Bar
|
|
|
|
a = []
|
|
for i in range(8):
|
|
a.append(Foo(random.randint(1, 10)))
|
|
print(*a)
|
|
print(*sorted(a))
|
|
```
|
|
|
|
Output:
|
|
|
|
```
|
|
Foo(0) Foo(1) Foo(2) Foo(1) Foo(9) Foo(5) Foo(5) Foo(8)
|
|
Foo(0) Foo(1) Foo(1) Foo(2) Foo(5) Foo(5) Foo(8) Foo(9)
|
|
```
|
|
|
|
### Remapping Key
|
|
|
|
- This method maps an object to another comparable datatype with which to be sorted. In this case, `Foo` is sorted by the sum of its members `x` and `y`.
|
|
|
|
|
|
<!-- Tested -->
|
|
```py
|
|
import random
|
|
class Foo:
|
|
def __init__(self, _Bar, _Baz): self.Bar,self.Baz = _Bar,_Baz
|
|
def __str__(self): return "Foo({},{})".format(self.Bar, self.Baz)
|
|
|
|
a = []
|
|
for i in range(8):
|
|
a.append(Foo(random.randint(1, 9)*10, random.randint(1, 9)))
|
|
print(*a)
|
|
|
|
print(*sorted(a, key=lambda foo: foo.Bar+foo.Baz))
|
|
def key(foo):
|
|
return foo.Bar + foo.Baz
|
|
print(*sorted(a, key=key))
|
|
```
|
|
|
|
Output:
|
|
|
|
```
|
|
Foo(10,2) Foo(30,2) Foo(60,6) Foo(90,7) Foo(80,7) Foo(80,9) Foo(60,9) Foo(90,8)
|
|
Foo(10,2) Foo(30,2) Foo(60,6) Foo(60,9) Foo(80,7) Foo(80,9) Foo(90,7) Foo(90,8)
|
|
Foo(10,2) Foo(30,2) Foo(60,6) Foo(60,9) Foo(80,7) Foo(80,9) Foo(90,7) Foo(90,8)
|
|
```
|
|
|
|
#### Function / Lambda
|
|
|
|
- This method defines how to compare two elements represented by an integer
|
|
- Positive: First term is greater than the second term
|
|
- Zero: First term and second term are equal
|
|
- Negative: First term is less than the second term
|
|
|
|
Note how the comparator must be converted to a `key`.
|
|
|
|
<!-- Tested -->
|
|
|
|
```py
|
|
import random
|
|
from functools import cmp_to_key
|
|
class Foo:
|
|
def __init__(self, _Bar): self.Bar = _Bar
|
|
def __str__(self): return "Foo({})".format(self.Bar)
|
|
|
|
a = []
|
|
for i in range(8):
|
|
a.append(Foo(random.randint(0, 9)))
|
|
print(*a)
|
|
|
|
print(*sorted(a, key=cmp_to_key(lambda foo1, foo2: foo1.Bar - foo2.Bar)))
|
|
def cmp(foo1, foo2):
|
|
return foo1.Bar - foo2.Bar
|
|
print(*sorted(a, key=cmp_to_key(cmp)))
|
|
```
|
|
|
|
Output:
|
|
|
|
```
|
|
Foo(0) Foo(1) Foo(2) Foo(1) Foo(9) Foo(5) Foo(5) Foo(8)
|
|
Foo(0) Foo(1) Foo(1) Foo(2) Foo(5) Foo(5) Foo(8) Foo(9)
|
|
Foo(0) Foo(1) Foo(1) Foo(2) Foo(5) Foo(5) Foo(8) Foo(9)
|
|
``` |