Sort #1: Selection Sort
- O(n^2) complexity
- Not particularly fast
- However, it is very simple. This makes it ideal for small data sets where efficiency isn’t super important.
- Not very memory intensive, the only real extra memory use is a single variable stored as temp. This means in memory constrained environemnts it can be ideal
public class SelectionSort {
public static void selectionSort(int[] arr) {
int n = arr.length;
// main iteration from each spot in the list
for (int i = 0; i < n-1; i++) {
// find the minimum element in unsorted array
int min_idx = i;
for (int j = i+1; j < n; j++) {
if (arr[j] < arr[min_idx]) { // compares current entry to the current minimum
min_idx = j; // if smaller, makes it the new minimum index
}
}
// swap the minimum element with the current element
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
public static void main(String[] args) {
int[] arr = {64, 25, 12, 22, 11};
selectionSort(arr);
System.out.println("Sorted array:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
SelectionSort.main(null);
Sorted array:
11 12 22 25 64
Sort #2: Quick Sort
- O(n log(n)) complexity
- Much more efficient than other O(n^2) algorithms
- Ideal for large data sets in which efficiency is important
- Quicksort’s method of partitioning data into smaller segments is also very repeatable, allowing for parallel computing and other more efficient methods because it’s so modular
public class QuickSort {
// Method to perform quicksort. High and Low start out as the length of the list and 0 respectively. They are incremented down through the partition process
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
// Partition the array and get the pivot index
int pi = partition(arr, low, high);
// Recursively sort elements before and after the pivot
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// Method to partition the array
public static int partition(int[] arr, int low, int high) {
// Select the pivot element (in this case, the last element)
int pivot = arr[high];
// Index of the smaller element
int i = low - 1;
// Traverse through the array
for (int j = low; j < high; j++) {
// If current element is smaller than or equal to the pivot
if (arr[j] < pivot) {
// Increment index of smaller element
i++;
// Swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Swap arr[i+1] and arr[high] (or the pivot)
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
// Return the partition index
return i + 1;
}
public static void main(String[] args) {
// Example array
int[] arr = {10, 7, 8, 9, 1, 5};
// Number of elements in the array
int n = arr.length;
// Call quickSort method to sort the array
quickSort(arr, 0, n - 1);
// Print the sorted array
System.out.println("Sorted array:");
for (int i = 0; i < n; ++i) {
System.out.print(arr[i] + " ");
}
}
}
Sort #3: Merge Sort
- O(n log(n)) complexity
- More efficient than other O(n^2) algorithms
- Ideal for large data sets in which efficiency is important
- Merge sort’s memory usage is fairly small, with a space complexity of O(n) so it can be useful in memory conservative situations
- The memory usage is also predictable, which benefits point 4
- Merge sort is also stable unlike the previous algorithms, meaning equivalent elements stay in the same order
public class MergeSort {
// Method to perform merge sort
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
// Find the middle point to divide the array into two halves
int mid = left + (right - left) / 2;
// Recursively sort the first and second halves
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
// Merge the sorted halves
merge(arr, left, mid, right);
}
}
// Method to merge two subarrays of arr[]
public static void merge(int[] arr, int left, int mid, int right) {
// Find sizes of two subarrays to be merged
int n1 = mid - left + 1;
int n2 = right - mid;
// Create temporary arrays
int[] L = new int[n1];
int[] R = new int[n2];
// Copy data to temporary arrays L[] and R[]
for (int i = 0; i < n1; i++) {
L[i] = arr[left + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[mid + 1 + j];
}
// Merge the temporary arrays back into arr[left..right]
// Initial indexes of first and second subarrays
int i = 0, j = 0;
// Initial index of merged subarray
int k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
// Copy remaining elements of L[] if any
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// Copy remaining elements of R[] if any
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
public static void main(String[] args) {
// Example array
int[] arr = {12, 11, 13, 5, 6, 7};
// Number of elements in the array
int n = arr.length;
// Call mergeSort method to sort the array
mergeSort(arr, 0, n - 1);
// Print the sorted array
System.out.println("Sorted array:");
for (int i = 0; i < n; ++i) {
System.out.print(arr[i] + " ");
}
}
}
MergeSort.main(null);
Sorted array:
5 6 7 11 12 13
Sort #4: Bubble Sort
- O(n^2) complexity
- Not particularly fast
- However, it is very simple. This makes it ideal for small data sets where efficiency isn’t super important.
- Not very memory intensive, good in environments where memory is constrained
- Efficient at sorting data sets that are already very close to being sorted, because it can terminate early if need be
public class BubbleSort {
// Function to perform bubble sort
public static void bubbleSort(int[] arr) {
int n = arr.length;
// Loop through the array
for (int i = 0; i < n - 1; i++) {
// Last i elements are already in place, so we iterate up to n - 1 - i
for (int j = 0; j < n - 1 - i; j++) {
// Swap if the element found is greater than the next element
if (arr[j] > arr[j + 1]) {
// Swap arr[j] and arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// Function to print the array
public static void printArray(int[] arr) {
int n = arr.length;
for (int i = 0; i < n; ++i) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
System.out.println("Original array:");
printArray(arr);
// Call the bubbleSort function
bubbleSort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
}
Sort #5: Insertion Sort
- O(n^2) complexity
- Not particularly fast
- However, it is very simple. This makes it ideal for small data sets where efficiency isn’t super important.
- Not very memory intensive, good in environments where memory is constrained
- Efficient at sorting data sets that are already very close to being sorted, because it can terminate early if need be
public class InsertionSort {
// Function to perform insertion sort
public static void insertionSort(int[] arr) {
int n = arr.length;
// Traverse through the array starting from the second element
for (int i = 1; i < n; i++) {
// Select the key element to be inserted
int key = arr[i];
int j = i - 1;
// Move elements of arr[0..i-1], that are greater than key, to one position ahead of their current position
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
// Insert the key element into the sorted sequence
arr[j + 1] = key;
}
}
// Function to print the array
public static void printArray(int[] arr) {
int n = arr.length;
for (int i = 0; i < n; ++i) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6};
System.out.println("Original array:");
printArray(arr);
// Call the insertionSort function
insertionSort(arr);
System.out.println("Sorted array:");
printArray(arr);
}
}
Comparable interface sorting
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
// defining the Collectable interface
interface Collectable<T> extends Comparable<T> {
@Override
int compareTo(T other);
String toString();
}
public class Electronic implements Comparable<Electronic>{
private String type;
private String model;
private int year;
public Electronic(String type, String model, int year){
this.type = type;
this.model = model;
this.year = year;
}
public void setModel(String model) {
this.model = model;
}
public void setYear(int year) {
this.year = year;
}
public String getType() {
return type;
}
public String getModel() {
return model;
}
public int getYear() {
return year;
}
@Override
public int compareTo(Electronic other){
return Integer.compare(this.getYear(), other.getYear());
}
@Override
public String toString() {
return "A " + this.getModel() + " " + this.getType() + " from " + Integer.toString(this.getYear());
}
public static void main(String[] args) {
CustomLinkedList<Electronic> electronics = new CustomLinkedList<>();
electronics.add(new Computer("Dell XPS 15", 2022, "NVIDIA GeForce RTX 3050 Ti", "Intel Core i7-11800H"));
electronics.add(new Computer("Apple MacBook Pro", 2021, "Apple M1 Pro", "Apple M1 Pro"));
electronics.add(new Computer("HP Spectre x360", 2020, "Intel Iris Xe Graphics", "Intel Core i7-1165G7"));
electronics.add(new Computer("Asus ROG Zephyrus G14", 2019, "NVIDIA GeForce RTX 3060", "AMD Ryzen 9 5900HS"));
electronics.add(new Computer("Lenovo ThinkPad X1 Carbon", 2018, "Intel Iris Xe Graphics", "Intel Core i7-1165G7"));
electronics.add(new Computer("Microsoft Surface Laptop Studio", 2023, "NVIDIA GeForce RTX 3050 Ti", "Intel Core i5-11300H"));
electronics.add(new Computer("Acer Predator Helios 300", 2020, "NVIDIA GeForce RTX 3060", "Intel Core i7-11800H"));
electronics.add(new Computer("Razer Blade 15", 2022, "NVIDIA GeForce RTX 3080", "Intel CoMore i9-11900H"));
electronics.add(new Tablet("Samsung Galaxy Tab S8", 2023, "265 ppi", "Qualcomm Snapdragon 8 Gen 1"));
electronics.add(new Tablet("Apple iPad Pro", 2022, "264 ppi", "Apple M1"));
electronics.add(new Tablet("Microsoft Surface Pro 8", 2021, "267 ppi", "Intel Core i7"));
electronics.add(new Tablet("Lenovo Tab P11 Pro", 2021, "263 ppi", "Qualcomm Snapdragon 730G"));
electronics.add(new Tablet("Google Pixel Slate", 2018, "293 ppi", "Intel Core i7"));
electronics.add(new Tablet("Amazon Fire HD 10", 2019, "224 ppi", "MediaTek MT8183"));
electronics.add(new Tablet("Huawei MatePad Pro", 2020, "280 ppi", "HiSilicon Kirin 990"));
electronics.add(new Tablet("Sony Xperia Tablet Z4", 2015, "299 ppi", "Qualcomm Snapdragon 810"));
electronics.add(new Phone("iPhone 13 Pro", 2021, "Triple-lens 12MP+12MP+12MP setup", "Apple A15 Bionic"));
electronics.add(new Phone("Samsung Galaxy S21 Ultra", 2021, "Quad-lens 108MP+12MP+10MP+10MP setup", "Exynos 2100 / Snapdragon 888"));
electronics.add(new Phone("Google Pixel 6 Pro", 2021, "Dual-lens 50MP+12MP setup", "Google Tensor"));
electronics.add(new Phone("OnePlus 10 Pro", 2023, "Quad-lens 48MP+50MP+8MP+2MP setup", "Qualcomm Snapdragon 8 Gen 1"));
electronics.add(new Phone("Xiaomi Mi 12", 2024, "Triple-lens 108MP+50MP+5MP setup", "Snapdragon 8 Gen 1"));
electronics.add(new Phone("Sony Xperia 1 III", 2021, "Triple-lens 12MP+12MP+12MP setup", "Qualcomm Snapdragon 888"));
electronics.add(new Phone("Huawei P50 Pro", 2021, "Quad-lens 50MP+40MP+13MP+3D ToF setup", "Kirin 9000 / Snapdragon 888"));
electronics.add(new Phone("Motorola Edge+", 2020, "Triple-lens 108MP+8MP+16MP setup", "Snapdragon 865"));
electronics.add(new Phone("iPhone X", 2017, "Dual-lens 12MP+12MP setup", "Apple A11 Bionic"));
electronics.add(new Phone("Samsung Galaxy S10", 2019, "Triple-lens 12MP+12MP+16MP setup", "Exynos 9820 / Snapdragon 855"));
electronics.add(new Phone("Google Pixel 3 XL", 2018, "Single-lens 12.2MP setup", "Qualcomm Snapdragon 845"));
electronics.add(new Phone("OnePlus 7 Pro", 2019, "Triple-lens 48MP+8MP+16MP setup", "Qualcomm Snapdragon 855"));
// for (Computer c : computers) {
// System.out.println(c.toString());
// System.out.println(c.compareTo(computers.get(0)));
// }
System.out.println("Unsorted List:\n");
Utilities.printList(electronics);
System.out.println("\nSorted List by group:\n");
electronics.selectionSort(electronics, true);
Utilities.printList(electronics);
System.out.println("\nSorted List without groups:\n");
electronics.selectionSort(electronics);
Utilities.printList(electronics);
}
}
public class Computer extends Electronic{
private String GPU;
private String CPU;
public Computer(String model, int year, String GPU, String CPU){
super("Computer", model, year);
this.GPU = GPU;
this.CPU = CPU;
}
public void setGPU(String GPU) {
this.GPU = GPU;
}
public void setCPU(String CPU) {
this.CPU = CPU;
}
public String getGPU() {
return GPU;
}
public String getCPU() {
return CPU;
}
@Override
public int compareTo(Electronic other){
return Integer.compare(this.getYear(), other.getYear());
}
@Override
public String toString() {
return "A " + this.getModel() + " " + this.getType() + " from " + Integer.toString(this.getYear()) + ", with a " + this.getGPU() + " graphics card and an " + this.getCPU() + " processor.";
}
}
public class Tablet extends Electronic{
private String pixelDensity;
private String processor;
public Tablet(String model, int year, String pixelDensity, String processor){
super("Tablet", model, year);
this.pixelDensity = pixelDensity;
this.processor = processor;
}
public void setPixelDensity(String GPU) {
this.pixelDensity = pixelDensity;
}
public void setProcessor(String CPU) {
this.processor = processor;
}
public String getPixelDensity() {
return pixelDensity;
}
public String getProcessor() {
return processor;
}
@Override
public int compareTo(Electronic other){
return Integer.compare(this.getYear(), other.getYear());
}
@Override
public String toString() {
return "A " + this.getModel() + " " + this.getType() + " from " + Integer.toString(this.getYear()) + ", with a pixel density of " + this.getPixelDensity() + " and an " + this.getProcessor() + " processor.";
}
}
public class Phone extends Electronic {
private String cameraSpec;
private String processor;
public Phone(String model, int year, String cameraSpec, String processor) {
super("Phone", model, year);
this.cameraSpec = cameraSpec;
this.processor = processor;
}
public void setCameraSpec(String cameraSpec) {
this.cameraSpec = cameraSpec;
}
public void setProcessor(String processor) {
this.processor = processor;
}
public String getCameraSpec() {
return cameraSpec;
}
public String getProcessor() {
return processor;
}
@Override
public int compareTo(Electronic other) {
return Integer.compare(this.getYear(), other.getYear());
}
@Override
public String toString() {
return "A " + this.getModel() + " " + this.getType() + " from " + this.getYear() + ", with a " + this.getCameraSpec() + " camera setup and a " + this.getProcessor() + " processor.";
}
}
public class CustomLinkedList<T> extends LinkedList<T> {
public CustomLinkedList(){
super();
}
public void selectionSort(CustomLinkedList<Electronic> list) {
// printList(list);
int n = list.size();
// main iteration from each spot in the list
for (int i = 0; i < n-1; i++) {
// find the minimum element in unsorted array
int min_idx = i;
for (int j = i+1; j < n; j++) {
if (list.get(j).compareTo(list.get(min_idx)) < 0) { // compares current entry to the current minimum
min_idx = j; // if smaller, makes it the new minimum index
}
}
// swap the minimum element with the current element
Electronic temp = list.get(min_idx);
list.set(min_idx, list.get(i));
list.set(i, temp);
}
return;
}
public void selectionSort(CustomLinkedList<Electronic> list, boolean group) {
if (!group){
selectionSort(list);
return;
}
// printList(list);
int n = list.size();
String currentType = "";
CustomLinkedList<Electronic> newList = new CustomLinkedList<>();
CustomLinkedList<Electronic> finalList = new CustomLinkedList<>();
for (Electronic e : list){
if(e.getType() != currentType && newList.size() == 0){
currentType = e.getType();
newList.addLast(e);
}
else if (e.getType() != currentType && newList.size() != 0){
this.selectionSort(newList);
for (Electronic el : newList){
finalList.addLast(el);
}
currentType = e.getType();
newList.clear();
}
else{
newList.addLast(e);
}
}
this.selectionSort(newList);
for (Electronic el : newList){
finalList.add(el);
}
return;
}
}
public class Utilities {
public static void printList(List<Electronic> list){
for (Electronic c : list){
System.out.println(c.toString());
}
}
}
Electronic.main(null);
Unsorted List:
A Dell XPS 15 Computer from 2022, with a NVIDIA GeForce RTX 3050 Ti graphics card and an Intel Core i7-11800H processor.
A Apple MacBook Pro Computer from 2021, with a Apple M1 Pro graphics card and an Apple M1 Pro processor.
A HP Spectre x360 Computer from 2020, with a Intel Iris Xe Graphics graphics card and an Intel Core i7-1165G7 processor.
A Asus ROG Zephyrus G14 Computer from 2019, with a NVIDIA GeForce RTX 3060 graphics card and an AMD Ryzen 9 5900HS processor.
A Lenovo ThinkPad X1 Carbon Computer from 2018, with a Intel Iris Xe Graphics graphics card and an Intel Core i7-1165G7 processor.
A Microsoft Surface Laptop Studio Computer from 2023, with a NVIDIA GeForce RTX 3050 Ti graphics card and an Intel Core i5-11300H processor.
A Acer Predator Helios 300 Computer from 2020, with a NVIDIA GeForce RTX 3060 graphics card and an Intel Core i7-11800H processor.
A Razer Blade 15 Computer from 2022, with a NVIDIA GeForce RTX 3080 graphics card and an Intel CoMore i9-11900H processor.
A Samsung Galaxy Tab S8 Tablet from 2023, with a pixel density of 265 ppi and an Qualcomm Snapdragon 8 Gen 1 processor.
A Apple iPad Pro Tablet from 2022, with a pixel density of 264 ppi and an Apple M1 processor.
A Microsoft Surface Pro 8 Tablet from 2021, with a pixel density of 267 ppi and an Intel Core i7 processor.
A Lenovo Tab P11 Pro Tablet from 2021, with a pixel density of 263 ppi and an Qualcomm Snapdragon 730G processor.
A Google Pixel Slate Tablet from 2018, with a pixel density of 293 ppi and an Intel Core i7 processor.
A Amazon Fire HD 10 Tablet from 2019, with a pixel density of 224 ppi and an MediaTek MT8183 processor.
A Huawei MatePad Pro Tablet from 2020, with a pixel density of 280 ppi and an HiSilicon Kirin 990 processor.
A Sony Xperia Tablet Z4 Tablet from 2015, with a pixel density of 299 ppi and an Qualcomm Snapdragon 810 processor.
A iPhone 13 Pro Phone from 2021, with a Triple-lens 12MP+12MP+12MP setup camera setup and a Apple A15 Bionic processor.
A Samsung Galaxy S21 Ultra Phone from 2021, with a Quad-lens 108MP+12MP+10MP+10MP setup camera setup and a Exynos 2100 / Snapdragon 888 processor.
A Google Pixel 6 Pro Phone from 2021, with a Dual-lens 50MP+12MP setup camera setup and a Google Tensor processor.
A OnePlus 10 Pro Phone from 2023, with a Quad-lens 48MP+50MP+8MP+2MP setup camera setup and a Qualcomm Snapdragon 8 Gen 1 processor.
A Xiaomi Mi 12 Phone from 2024, with a Triple-lens 108MP+50MP+5MP setup camera setup and a Snapdragon 8 Gen 1 processor.
A Sony Xperia 1 III Phone from 2021, with a Triple-lens 12MP+12MP+12MP setup camera setup and a Qualcomm Snapdragon 888 processor.
A Huawei P50 Pro Phone from 2021, with a Quad-lens 50MP+40MP+13MP+3D ToF setup camera setup and a Kirin 9000 / Snapdragon 888 processor.
A Motorola Edge+ Phone from 2020, with a Triple-lens 108MP+8MP+16MP setup camera setup and a Snapdragon 865 processor.
A iPhone X Phone from 2017, with a Dual-lens 12MP+12MP setup camera setup and a Apple A11 Bionic processor.
A Samsung Galaxy S10 Phone from 2019, with a Triple-lens 12MP+12MP+16MP setup camera setup and a Exynos 9820 / Snapdragon 855 processor.
A Google Pixel 3 XL Phone from 2018, with a Single-lens 12.2MP setup camera setup and a Qualcomm Snapdragon 845 processor.
A OnePlus 7 Pro Phone from 2019, with a Triple-lens 48MP+8MP+16MP setup camera setup and a Qualcomm Snapdragon 855 processor.
Sorted List by group:
A Dell XPS 15 Computer from 2022, with a NVIDIA GeForce RTX 3050 Ti graphics card and an Intel Core i7-11800H processor.
A Apple MacBook Pro Computer from 2021, with a Apple M1 Pro graphics card and an Apple M1 Pro processor.
A HP Spectre x360 Computer from 2020, with a Intel Iris Xe Graphics graphics card and an Intel Core i7-1165G7 processor.
A Asus ROG Zephyrus G14 Computer from 2019, with a NVIDIA GeForce RTX 3060 graphics card and an AMD Ryzen 9 5900HS processor.
A Lenovo ThinkPad X1 Carbon Computer from 2018, with a Intel Iris Xe Graphics graphics card and an Intel Core i7-1165G7 processor.
A Microsoft Surface Laptop Studio Computer from 2023, with a NVIDIA GeForce RTX 3050 Ti graphics card and an Intel Core i5-11300H processor.
A Acer Predator Helios 300 Computer from 2020, with a NVIDIA GeForce RTX 3060 graphics card and an Intel Core i7-11800H processor.
A Razer Blade 15 Computer from 2022, with a NVIDIA GeForce RTX 3080 graphics card and an Intel CoMore i9-11900H processor.
A Samsung Galaxy Tab S8 Tablet from 2023, with a pixel density of 265 ppi and an Qualcomm Snapdragon 8 Gen 1 processor.
A Apple iPad Pro Tablet from 2022, with a pixel density of 264 ppi and an Apple M1 processor.
A Microsoft Surface Pro 8 Tablet from 2021, with a pixel density of 267 ppi and an Intel Core i7 processor.
A Lenovo Tab P11 Pro Tablet from 2021, with a pixel density of 263 ppi and an Qualcomm Snapdragon 730G processor.
A Google Pixel Slate Tablet from 2018, with a pixel density of 293 ppi and an Intel Core i7 processor.
A Amazon Fire HD 10 Tablet from 2019, with a pixel density of 224 ppi and an MediaTek MT8183 processor.
A Huawei MatePad Pro Tablet from 2020, with a pixel density of 280 ppi and an HiSilicon Kirin 990 processor.
A Sony Xperia Tablet Z4 Tablet from 2015, with a pixel density of 299 ppi and an Qualcomm Snapdragon 810 processor.
A iPhone 13 Pro Phone from 2021, with a Triple-lens 12MP+12MP+12MP setup camera setup and a Apple A15 Bionic processor.
A Samsung Galaxy S21 Ultra Phone from 2021, with a Quad-lens 108MP+12MP+10MP+10MP setup camera setup and a Exynos 2100 / Snapdragon 888 processor.
A Google Pixel 6 Pro Phone from 2021, with a Dual-lens 50MP+12MP setup camera setup and a Google Tensor processor.
A OnePlus 10 Pro Phone from 2023, with a Quad-lens 48MP+50MP+8MP+2MP setup camera setup and a Qualcomm Snapdragon 8 Gen 1 processor.
A Xiaomi Mi 12 Phone from 2024, with a Triple-lens 108MP+50MP+5MP setup camera setup and a Snapdragon 8 Gen 1 processor.
A Sony Xperia 1 III Phone from 2021, with a Triple-lens 12MP+12MP+12MP setup camera setup and a Qualcomm Snapdragon 888 processor.
A Huawei P50 Pro Phone from 2021, with a Quad-lens 50MP+40MP+13MP+3D ToF setup camera setup and a Kirin 9000 / Snapdragon 888 processor.
A Motorola Edge+ Phone from 2020, with a Triple-lens 108MP+8MP+16MP setup camera setup and a Snapdragon 865 processor.
A iPhone X Phone from 2017, with a Dual-lens 12MP+12MP setup camera setup and a Apple A11 Bionic processor.
A Samsung Galaxy S10 Phone from 2019, with a Triple-lens 12MP+12MP+16MP setup camera setup and a Exynos 9820 / Snapdragon 855 processor.
A Google Pixel 3 XL Phone from 2018, with a Single-lens 12.2MP setup camera setup and a Qualcomm Snapdragon 845 processor.
A OnePlus 7 Pro Phone from 2019, with a Triple-lens 48MP+8MP+16MP setup camera setup and a Qualcomm Snapdragon 855 processor.
Sorted List without groups:
A Sony Xperia Tablet Z4 Tablet from 2015, with a pixel density of 299 ppi and an Qualcomm Snapdragon 810 processor.
A iPhone X Phone from 2017, with a Dual-lens 12MP+12MP setup camera setup and a Apple A11 Bionic processor.
A Lenovo ThinkPad X1 Carbon Computer from 2018, with a Intel Iris Xe Graphics graphics card and an Intel Core i7-1165G7 processor.
A Google Pixel Slate Tablet from 2018, with a pixel density of 293 ppi and an Intel Core i7 processor.
A Google Pixel 3 XL Phone from 2018, with a Single-lens 12.2MP setup camera setup and a Qualcomm Snapdragon 845 processor.
A Asus ROG Zephyrus G14 Computer from 2019, with a NVIDIA GeForce RTX 3060 graphics card and an AMD Ryzen 9 5900HS processor.
A Amazon Fire HD 10 Tablet from 2019, with a pixel density of 224 ppi and an MediaTek MT8183 processor.
A Samsung Galaxy S10 Phone from 2019, with a Triple-lens 12MP+12MP+16MP setup camera setup and a Exynos 9820 / Snapdragon 855 processor.
A OnePlus 7 Pro Phone from 2019, with a Triple-lens 48MP+8MP+16MP setup camera setup and a Qualcomm Snapdragon 855 processor.
A Acer Predator Helios 300 Computer from 2020, with a NVIDIA GeForce RTX 3060 graphics card and an Intel Core i7-11800H processor.
A Huawei MatePad Pro Tablet from 2020, with a pixel density of 280 ppi and an HiSilicon Kirin 990 processor.
A Motorola Edge+ Phone from 2020, with a Triple-lens 108MP+8MP+16MP setup camera setup and a Snapdragon 865 processor.
A HP Spectre x360 Computer from 2020, with a Intel Iris Xe Graphics graphics card and an Intel Core i7-1165G7 processor.
A Microsoft Surface Pro 8 Tablet from 2021, with a pixel density of 267 ppi and an Intel Core i7 processor.
A iPhone 13 Pro Phone from 2021, with a Triple-lens 12MP+12MP+12MP setup camera setup and a Apple A15 Bionic processor.
A Samsung Galaxy S21 Ultra Phone from 2021, with a Quad-lens 108MP+12MP+10MP+10MP setup camera setup and a Exynos 2100 / Snapdragon 888 processor.
A Google Pixel 6 Pro Phone from 2021, with a Dual-lens 50MP+12MP setup camera setup and a Google Tensor processor.
A Sony Xperia 1 III Phone from 2021, with a Triple-lens 12MP+12MP+12MP setup camera setup and a Qualcomm Snapdragon 888 processor.
A Huawei P50 Pro Phone from 2021, with a Quad-lens 50MP+40MP+13MP+3D ToF setup camera setup and a Kirin 9000 / Snapdragon 888 processor.
A Lenovo Tab P11 Pro Tablet from 2021, with a pixel density of 263 ppi and an Qualcomm Snapdragon 730G processor.
A Apple MacBook Pro Computer from 2021, with a Apple M1 Pro graphics card and an Apple M1 Pro processor.
A Dell XPS 15 Computer from 2022, with a NVIDIA GeForce RTX 3050 Ti graphics card and an Intel Core i7-11800H processor.
A Apple iPad Pro Tablet from 2022, with a pixel density of 264 ppi and an Apple M1 processor.
A Razer Blade 15 Computer from 2022, with a NVIDIA GeForce RTX 3080 graphics card and an Intel CoMore i9-11900H processor.
A OnePlus 10 Pro Phone from 2023, with a Quad-lens 48MP+50MP+8MP+2MP setup camera setup and a Qualcomm Snapdragon 8 Gen 1 processor.
A Microsoft Surface Laptop Studio Computer from 2023, with a NVIDIA GeForce RTX 3050 Ti graphics card and an Intel Core i5-11300H processor.
A Samsung Galaxy Tab S8 Tablet from 2023, with a pixel density of 265 ppi and an Qualcomm Snapdragon 8 Gen 1 processor.
A Xiaomi Mi 12 Phone from 2024, with a Triple-lens 108MP+50MP+5MP setup camera setup and a Snapdragon 8 Gen 1 processor.