NBAPlayer class with comparable implementation
// NBAPlayer class, which implements the Comparable interface with type parameter NBAPlayer
public class NBAPlayer implements Comparable<NBAPlayer>{
private String name; // Player's name
private String nickname; // Player's nickname
private int weight; // Player's weight in pounds
// Constructor to initialize NBAPlayer object
public NBAPlayer(String name, String nickname, int weight) {
this.name = name;
this.nickname = nickname;
this.weight = weight;
}
// Getter method for player's name
public String getName() {
return name;
}
// Getter method for player's nickname
public String getNickname() {
return nickname;
}
// Getter method for player's weight
public int getWeight() {
return weight;
}
// Override toString() to provide a custom string representation of NBAPlayer
@Override
public String toString() {
return String.format("%s a.k.a %s", name, nickname);
}
// Override compareTo() method to compare NBAPlayer objects based on weight
@Override
public int compareTo(NBAPlayer other) {
return Integer.compare(this.weight, other.weight);
}
}
Team class
import java.util.ArrayList;
import java.util.Random;
public class Team<T extends Comparable<T>> extends ArrayList<T>{
private ArrayList<NBAPlayer> Team;
public Team(int count) {
this.Team = new ArrayList<>();
populateTeam(count);
}
private void populateTeam(int count) {
String[] names = {"LeBron James", "Kevin Durant", "Stephen Curry", "Giannis Antetokounmpo", "Kawhi Leonard", "James Harden"};
String[] nicknames = {"King James", "KD", "Steph", "Greek Freak", "Kawhi", "The Beard"};
Random random = new Random();
for (int i = 0; i < count; i++) {
int idx = random.nextInt(names.length);
int weight = random.nextInt(100) + 180; // Generating weight between 180 and 280 pounds
Team.add(new NBAPlayer(names[idx], nicknames[idx], weight));
}
}
public void bubbleSort() {
int n = Team.size();
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (Team.get(j).compareTo(Team.get(j + 1)) > 0) {
NBAPlayer temp = Team.get(j);
Team.set(j, Team.get(j + 1));
Team.set(j + 1, temp);
}
}
}
}
public void selectionSort() {
int n = Team.size();
for (int i = 0; i < n - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < n; j++) {
if (Team.get(j).compareTo(Team.get(min_idx)) < 0)
min_idx = j;
}
NBAPlayer temp = Team.get(min_idx);
Team.set(min_idx, Team.get(i));
Team.set(i, temp);
}
}
public void insertionSort() {
int n = Team.size();
for (int i = 1; i < n; ++i) {
NBAPlayer key = Team.get(i);
int j = i - 1;
while (j >= 0 && Team.get(j).compareTo(key) > 0) {
Team.set(j + 1, Team.get(j));
j = j - 1;
}
Team.set(j + 1, key);
}
}
public void mergeSort() {
mergeSortHelper(0, Team.size() - 1);
}
private void mergeSortHelper(int left, int right) {
if (left < right) {
int middle = (left + right) / 2;
mergeSortHelper(left, middle);
mergeSortHelper(middle + 1, right);
merge(left, middle, right);
}
}
private void merge(int left, int middle, int right) {
int n1 = middle - left + 1;
int n2 = right - middle;
ArrayList<NBAPlayer> L = new ArrayList<>(n1);
ArrayList<NBAPlayer> R = new ArrayList<>(n2);
for (int i = 0; i < n1; ++i)
L.add(i, Team.get(left + i));
for (int j = 0; j < n2; ++j)
R.add(j, Team.get(middle + 1 + j));
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L.get(i).compareTo(R.get(j)) <= 0) {
Team.set(k, L.get(i));
i++;
} else {
Team.set(k, R.get(j));
j++;
}
k++;
}
while (i < n1) {
Team.set(k, L.get(i));
i++;
k++;
}
while (j < n2) {
Team.set(k, R.get(j));
j++;
k++;
}
}
public void quickSort() {
quickSortHelper(0, Team.size() - 1);
}
private void quickSortHelper(int low, int high) {
if (low < high) {
int pi = partition(low, high);
quickSortHelper(low, pi - 1);
quickSortHelper(pi + 1, high);
}
}
private int partition(int low, int high) {
NBAPlayer pivot = Team.get(high);
int i = (low - 1);
for (int j = low; j < high; j++) {
if (Team.get(j).compareTo(pivot) < 0) {
i++;
NBAPlayer temp = Team.get(i);
Team.set(i, Team.get(j));
Team.set(j, temp);
}
}
NBAPlayer temp = Team.get(i + 1);
Team.set(i + 1, Team.get(high));
Team.set(high, temp);
return i + 1;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (NBAPlayer player : Team) {
sb.append(player.toString()).append("\n");
}
return sb.toString();
}
public static void main(String[] args) {
Team<NBAPlayer> Team = new Team(10000);
long startTime = System.currentTimeMillis();
Team.bubbleSort();
long endTime = System.currentTimeMillis();
System.out.println("Bubble Sort took: " + (endTime - startTime) + " ms");
Team = new Team(10000);
startTime = System.currentTimeMillis();
Team.selectionSort();
endTime = System.currentTimeMillis();
System.out.println("Selection Sort took: " + (endTime - startTime) + " ms");
Team = new Team(10000);
startTime = System.currentTimeMillis();
Team.insertionSort();
endTime = System.currentTimeMillis();
System.out.println("Insertion Sort took: " + (endTime - startTime) + " ms");
Team = new Team(10000);
startTime = System.currentTimeMillis();
Team.mergeSort();
endTime = System.currentTimeMillis();
System.out.println("Merge Sort took: " + (endTime - startTime) + " ms");
Team = new Team(10000);
startTime = System.currentTimeMillis();
Team.quickSort();
endTime = System.currentTimeMillis();
System.out.println("Quick Sort took: " + (endTime - startTime) + " ms");
}
}
Bubble Sort took: 250 ms
Selection Sort took: 160 ms
Insertion Sort took: 118 ms
Merge Sort took: 20 ms
Quick Sort took: 78 ms
NBAPlayerList class (linked list implementation):
import java.util.Random;
class NBAPlayer<NBAPlayer extends Comparable<NBAPlayer>> {
private String name;
private String nickname;
private int weight;
public NBAPlayer(String name, String nickname, int weight) {
this.name = name;
this.nickname = nickname;
this.weight = weight;
}
@Override
public int compareTo(NBAPlayer other) {
return Integer.compare(this.weight, other.weight);
}
@Override
public String toString() {
return String.format("%s a.k.a %s (Weight: %d)", name, nickname, weight);
}
}
class NBAPlayerNode {
NBAPlayer data;
NBAPlayerNode next;
public NBAPlayerNode(NBAPlayer data) {
this.data = data;
this.next = null;
}
}
class NBAPlayerList<NBAPlayer extends Comparable<NBAPlayer>> extends ArrayList<NBAPlayer>{
private NBAPlayerNode head;
public NBAPlayerList() {
this.head = null;
}
public void add(NBAPlayer data) {
NBAPlayerNode newNode = new NBAPlayerNode(data);
if (head == null) {
head = newNode;
} else {
NBAPlayerNode current = head;
while (current.next != null) {
current = current.next;
}
current.next = newNode;
}
}
public void printList() {
NBAPlayerNode temp = head;
while (temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.println("null");
}
public void quickSort() {
quickSortHelper(head, getTail(head));
}
private void quickSortHelper(NBAPlayerNode head, NBAPlayerNode end) {
if (head != end && head != null && end != null) {
NBAPlayerNode partitionNode = partition(head, end);
quickSortHelper(head, partitionNode);
quickSortHelper(partitionNode.next, end);
}
}
private NBAPlayerNode partition(NBAPlayerNode start, NBAPlayerNode end) {
if (start == end || start == null || end == null)
return start;
NBAPlayerNode pivotPrev = start;
NBAPlayerNode curr = start;
NBAPlayer pivot = end.data;
while (start != end) {
if (start.data.compareTo(pivot) < 0) {
NBAPlayer temp = curr.data;
curr.data = start.data;
start.data = temp;
curr = curr.next;
}
start = start.next;
}
NBAPlayer temp = curr.data;
curr.data = pivot;
end.data = temp;
return pivotPrev;
}
private NBAPlayerNode getTail(NBAPlayerNode node) {
while (node != null && node.next != null) {
node = node.next;
}
return node;
}
public static void main(String[] args) {
NBAPlayerList list = new NBAPlayerList();
Random random = new Random();
String[] names = {"LeBron James", "Kevin Durant", "Stephen Curry", "Giannis Antetokounmpo", "Kawhi Leonard", "James Harden"};
String[] nicknames = {"King James", "KD", "Steph", "Greek Freak", "Kawhi", "The Beard"};
for (int i = 0; i < 10; i++) { // Reduced to 10 players for demonstration
int idx = random.nextInt(names.length);
int weight = random.nextInt(100) + 180;
list.add(new NBAPlayer(names[idx], nicknames[idx], weight));
}
System.out.println("Unsorted List:");
list.printList(); // Print unsorted list
list.quickSort(); // Perform quick sort
System.out.println("\nSorted List:");
list.printList(); // Print sorted list
}
}
Unsorted List:
Stephen Curry a.k.a Steph (Weight: 234) -> Giannis Antetokounmpo a.k.a Greek Freak (Weight: 260) -> Kawhi Leonard a.k.a Kawhi (Weight: 259) -> LeBron James a.k.a King James (Weight: 260) -> Kevin Durant a.k.a KD (Weight: 246) -> Stephen Curry a.k.a Steph (Weight: 236) -> Giannis Antetokounmpo a.k.a Greek Freak (Weight: 236) -> LeBron James a.k.a King James (Weight: 270) -> James Harden a.k.a The Beard (Weight: 197) -> James Harden a.k.a The Beard (Weight: 261) -> null
Sorted List:
James Harden a.k.a The Beard (Weight: 197) -> Stephen Curry a.k.a Steph (Weight: 234) -> Stephen Curry a.k.a Steph (Weight: 236) -> Giannis Antetokounmpo a.k.a Greek Freak (Weight: 236) -> Kevin Durant a.k.a KD (Weight: 246) -> LeBron James a.k.a King James (Weight: 260) -> Giannis Antetokounmpo a.k.a Greek Freak (Weight: 260) -> Kawhi Leonard a.k.a Kawhi (Weight: 259) -> LeBron James a.k.a King James (Weight: 261) -> James Harden a.k.a The Beard (Weight: 270) -> null