I have an arrayList of Students in my main class called S... of objects type student. In "s", i need to sort my Students in my arrayList "S" by the registrationNumber they have, smaller to higher.
I tried many ways, but cannot get it to work...
public static void sort(){
int small;
for (int i=0; i < s.size() -1;i++){
small = i;
for (int ind = i + 1; ind< s.size(); ind++ ){
if( stud.get(ind).getRegNum() < s.get(small).getRegNum() ){
small = ind;
swap(i, small);
}
}
}
}
public static void swap(int one,int two){
}
You should check out java collections.
see http://docs.oracle.com/javase/tutorial/collections/interfaces/order.html
I assume that your student class has a public variable registrationNumber
public class StudentComparator implements Comparator<Student>{
#Override
public int compare(Student o1, Student o2) {
return (o1.registrationNumber>o2.registrationNumber);
}
}
somewhere call:
Collections.sort(students, new StudentComparator ());
Call Collections.sort(yourStudentList);
Your student class have to implement the interface Comparable
Override the comparteTo() method of the interface.
That's it!
Example for a comparator(assume registrationNumber is an integer):
#Override
public int compareTo(Student o) {
if(null== o)
return 1;
if(registrationNumber == 0 && o.registrationNumber==0)
return 0;
if(registrationNumber == 0 && o.registrationNumber!=0)
return -1;
if(registrationNumber != 0 && o.registrationNumber==0)
return 1;
return o.registrationNumber.compareTo(registrationNumber);
}
return 1 //when o is less than this
return -1 //when o is bigger than this
return 0 //when they are equal
EDIT If you need to use selectionsort, than you need this comparator too and the interface compareable. But then you only have so creat a custom sort() function which implements the selectionsort algorithm.
Related
I am trying to check whether my levelorder of my Binary Search Tree is equal to the other one. To do this, I tried to make a compareTo method. I only give equal values to the method, but it keeps on saying the condition is false. When I place breakpoints, I see that the values are still equal. I am probably not understanding it correctly. Does anyone know how to solve this?
Here is what I did, as you can see below, the compareTo returns a 1 instead of a 0:
import edu.princeton.cs.algs4.BST;
import java.util.*;
public class MyBST implements Comparable<MyBST>{
private Object e;
public MyBST(Object e){
this.e = e;
}
private Object getE(){
return e;
}
public static void main(String[] args) {
int size = 4;
Random r = new Random();
Set<Integer> tes = new LinkedHashSet<>(size);
Stack<Integer> stack = new Stack<>();
while (tes.size() < size) {
tes.add(r.nextInt(10));
}
System.out.println("possible combinations");
Set<Stack<Integer>> combos = combos(tes, stack, tes.size());
Object[] arr = combos.toArray();
List<String> d = new ArrayList<>();
for (Object s : arr) {
String b = s.toString();
b = b.replaceAll("\\[", "").replaceAll("\\]", "");
d.add(b);
}
int index = 0;
do {
BST<String, Integer> bst1 = new BST<String, Integer>();
BST<String, Integer> bst2 = new BST<String, Integer>();
String key1 = d.get(index);
String key2 = d.get(index);
key1 = key1.replaceAll(" ", "");
String[] m = key1.split(",");
key2 = key2.replaceAll(" ", "");
String[] n = key2.split(",");
System.out.println("1e order");
for (int j = 0; j < m.length; j++) {
System.out.println(m[j]);
bst1.put(m[j], 0);
}
System.out.println("2e order");
for (int j = 0; j < n.length; j++) {
System.out.println(n[j]);
bst2.put(n[j], 0);
}
System.out.println("levelorder 1e BST");
MyBST e = new MyBST(bst1.levelOrder());
MyBST y = new MyBST(bst2.levelOrder());
System.out.println(bst1.levelOrder());
System.out.println("levelorder 2e BST");
System.out.println(bst2.levelOrder());
System.out.println(e.compareTo(y) + "\n");
index++;
} while (index < arr.length - 1);
}
public static Set<Stack<Integer>> combos(Set<Integer> items, Stack<Integer> stack, int size) {
Set<Stack<Integer>> set = new HashSet<>();
if (stack.size() == size) {
set.add((Stack) stack.clone());
}
Integer[] itemz = items.toArray(new Integer[0]);
for (Integer i : itemz) {
stack.push(i);
items.remove(i);
set.addAll(combos(items, stack, size));
items.add(stack.pop());
}
return set;
}
#Override
public int compareTo(MyBST o) {
if (this.e == o.e) {
return 0;
}
else
return 1;
}
}
Here you can find the BST.java class: BST.java
And the output is something like:
The breakpoint at the compareTo method says:
When you're using the == operator you're actually checking to see if the references point to the same object in memory. From your debugging screenshot you can see that they are not. this.e points to object Queue#817 while o.e points to Queue#819.
If all you want to do is test for equality, then just override equals and hashCode. You can do it like this (rest of class omitted):
public class MyBST {
private Object e;
public MyBST(Object e) {
this.e = e;
}
public Object getE(){
return e;
}
#Override
public int hashCode() {
return Objects.hashCode(e);
}
#Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!(obj instanceof MyBST))
return false;
MyBST me = (MyBST) obj;
if (e == null) {
if (me.e != null)
return false;
} else if (!e.equals(me.e))
return false;
return true;
}
}
Implementing Comparable is more involved since you need to check for less, equal, or greater than other instances of MyBST. Unfortunately, the only field in MyBST is an Object which does not tell you anything about its actual fields. So without specific fields with which to test you need to ensure that the Object you pass also implements Comparable. Then you can declare your class like this. Rest of class omitted.
It simply says that
MyBST is comparable.
And the object that is passed in the constructor is comparable.
class MyBST<T extends Comparable<? super T>> implements Comparable<MyBST<T>>{
private T e;
public MyBST(T e){
this.e = e;
}
public T getE(){
return e;
}
#Override
public int compareTo(MyBST<T> o) {
return e.compareTo(o.e);
}
}
The other alternative is to simply pass the actual object type and store it as such, not as Object. Then just implement Comparable in MyBST and use the appropriate fields of the passed object. Lets say the object was an Apple object, you could do this.
class Apple {
String type;
int weight;
}
class MyBST implements Comparable<MyBST> {
private Apple apple;
public MyBST(Apple apple) {
this.apple = apple;
}
#Override
public int compareTo(MyBST e) {
// this could be different depending on how you wanted
// to compare one apple to another. This comparison favors
// type over weight.
// check type - String class implements comparable
int ret = apple.type.compareTo(e.apple.type);
if (ret != 0) {
return ret;
}
// same type so check weight
if (apple.weight < e.apple.weight) {
return -1;
}
if (apple.weight > e.apple.weight) {
return 1;
}
return 0; // equals apples based on criteria
}
}
Finally, you have this.
private Object getE(){
return e;
}
A private getter is not usually very useful. Make it public.
I have a class Item, which implements Comparable, and has a compareTo method. I want to compare the object o to other Items. I casted o to Item.
In a separate class, Inventory, I have a method for inserting items into the inventory. But I only want to insert if their product numbers are different. So I try to call the compareTo() method to compare item numbers but get a stackoverflow error.
I've tried p.compareTo(iter.next), because I want it to cycle through all of the items in the list. Sorry the formatting isn't perfect. first post here.
public class item{
public int compareTo(Object o){
result = compareTo((Product)o);
if (result < 0){
return -1;
}
else if (result == 0){
return 0;
}
else{
return 1;
}
}
}
public class ProductInventory extends Product {
private void insert(Product p){
Iterator<Product> iter = list.iterator();
if (list.size() == 0) {
list.addFirst(p);
}
while(iter.hasNext()) {
p.compareTo(iter.next());
//if (p.getNumber() != iter.next().getNumber()) {
System.out.print("RESULT:" + result);
if (result != 0) {
list.addFirst(p);
}
else {
System.out.print("DUPLICATE");
}
iter.next();
}
}
I want it to print duplicate if result = 0 (the numbers are the same), otherwise add it to list.
The compareTo method in your item class is infinitely recursing on this line:
result = compareTo((Product)o); //this is a self-call!
You want to replace that line with the implementation for your compareTo, for example:
result = this.value - that.value; //insert actual logic here
Maybe you need this:
public class ProductInventory extends Product {
private void insert(Product p) {
if (!list.contains(p)) {
list.add(0, p);
}
}
}
I have been given the following main method and must write the code for the ObjectList class. I am supposed to infer the necessary functions of the ObjectList class and write the class myself, however I am unsure exactly what I need to do to fulfill this function. Any help understanding this is greatly appreciated. This is the code I was given:
ObjectList ol = new ObjectList(3);
String s = "Im Happy";
Dog d = new Dog();
DVD v = new DVD();
Integer i = 1234;
System.out.println(ol.add(s));
System.out.println(ol.add(d));
System.out.println(ol.add(v));
System.out.println(ol.add(i));
ol.remove(0);
System.out.println(ol.add(i));
System.out.println("Is the list full? "+ isFull());
System.out.println("Is the list empty? "+ isEmpty());
System.out.println("Total number of objects in the list: " + getTotal());
Object g = ol.getObject(1);
g.bark();
It's quite simple just need to create a list of Object types using ArrayList or LinkedList in the ObjectList class and implement the function as follows
public class ObjectList{
private ArrayList<Object> objects;
public ObjectList(int size)
{
objects = new ArrayList<Object>(size);
}
public String add (Object object)
{
objects.add(object);
//anything you would like to return I'm just returning a string
return "Object Added";
}
public void remove (int index)
{
objects.remove(index);
}
public boolean isEmpty()
{
return objects.isEmpty();
}
public int getTotal()
{
return objects.size();
}
public Object getObject(int index)
{
return objects.get(index);
}
}
The isFull()is not needed since ArrayListsize can change dynamically. You can use a simple array instead of ArrayList and then implement the isFull() function.
Also when getting an object using the get getObject() function, you need to cast it to the correct type before using there function. In your code g.bark() won't work because Object doesn't have a bark function
Object g = ol.getObject(1);
//This can give a runtime error if g is not a Dog
//Use try catch when casting
Dog d = (Dog)g;
d.bark();
EDIT
This is how you would implement isFull() and other functions if using arrays instead of ArrayList but for the sake of simplicity use the ArrayList version
public class ObjectList{
private Object[] objects;
private int size = 0;
private int currentIndex = 0;
public ObjectList(int size)
{
this.size = size;
objects = new Object[size];
}
private boolean isFull() {
if(currentIndex == size)
return true;
else
return false;
}
public String add (java.lang.Object object)
{
if ( ! isFull() ) {
objects[currentIndex] = object;
currentIndex++;
return "Object added";
}
return "List full : object not added";
}
public void remove (int index)
{
if( !isEmpty() ) {
//shifting all the object to the left of deleted object 1 index to the left to fill the empty space
for (int i = index; i < size - 1; i++) {
objects[i] = objects[i + 1];
}
currentIndex--;
}
}
public boolean isEmpty()
{
if(currentIndex == 0)
return true;
else
return false;
}
public int getTotal()
{
return currentIndex;
}
public java.lang.Object getObject(int index)
{
if(index < currentIndex)
return objects[index];
else
return null;
}
}
What it seems you want to achieve is "expand" the functionality of an ArrayList and create a custom list of objects. What you could do is to create a class extending the ArrayList and define/override any other methods you want.
public class ObjectList extends ArrayList<Object> {
//constructor with initial capacity
private int length;
public ObjectList(int size){
super(size);
this.length= size;
}
public Object getObject(int index){
return this.get(index);
}
}
Now you have the add and remove functions inherited from the ArrayList class and the getObject method.
Concerning the isFull method, you can check if the size of your ObjectList class is equal to the size it was instantiated with
if(this.size() == this.length){
return true
}
return false;
And getTotal
public int getTotal(){
return this.size();
}
What is the correct way to use the compareTo inside for loop? I'd like to sort the Course objects in ascending order inside the array. I'm worried about the correct syntax for compareTo inside a loop in my insert() method.
if((array[i].courseNumber.compareTo(object.courseNumber)) <= 0) - is giving me error.
public class Courses implements Comparable{
private String title;
private int courseNumber;
private Courses[] array;
private int size;
public Courses(String title, int courseNumber){
this.title = title;
this.courseNumber = courseNumber;
this.array = new Courses[10];
this.size = 0;
}
public void insert(String title, int courseNumber){
Courses object = new Courses(title, courseNumber);
if(size == 0){
array[0] = object;
}
else{
int i;
for(i = 0; i < size; i++){
if((array[i].courseNumber.compareTo(object.courseNumber)) <= 0)
//do STUFF
}
}
}
#Override
public int compareTo(Object o) {
if(o instanceof Courses){
Courses obj1 = (Courses)o;
return this.courseNumber - obj1.courseNumber;
}
return -1;
}
}
if((array[i].courseNumber.compareTo(object.courseNumber)) <= 0)
Is giving you an error because courseNumber is a primitive (not an object), so there is no compareTo method defined on it.
If you would like to use that syntax to compare integers, you can use the static Integer.compare method.
if(Integer.compare(array[i].courseNumber, object.courseNumber) <= 0)
If you want to use your defined compareTo method then do
if(array[i].compareTo(object) <= 0))
Hint : You are not passing the object as parameter.
How does this compare two objects ?
for(i = 0; i < size; i++){
if((array[i].courseNumber.compareTo(object.courseNumber)) <= 0)
//do STUFF
}
You should look at Arrays.sort(Object[]) which will take care about ordering it using the Comparable interface.
I am using a Max-Heap to store objects of type Song. A song has a title and a rating as shown in the Song class. I want the Song object to be compared by rating so that the highest rated songs are displayed first. If songs have the same rating then they should be compared by alphabetical order of title. What I have now is currently outputting it by highest rating, but incorrectly.
Heap:
public class Heap<T extends Comparable<T>> {
private ArrayList<T> heap;
public Heap(){
heap = new ArrayList<T>();
}
public int getPLoc(int i){
return (i - 1) / 2;
}
public int getLCLoc(int i){
return 2 * i + 1;
}
public int getRCLoc(int i){
return 2 * i + 2;
}
public T getNodeAt(int i) {
if(heap.get(i) == null) {
System.out.println("Item does not exist.");
return null;
}else {
return heap.get(i);
}
}
public void addNode(T n) {
heap.add(null);
int index = heap.size() - 1;
while(index > 0 && (getNodeAt(getPLoc(index)).compareTo(n)) < 0) { //Is this correct?
heap.set(index, getNodeAt(getPLoc(index)));
index = getPLoc(index);
}
heap.set(index, n);
}
Song:
public class Song implements Comparable<Song> {
private String title;
private String rating;
public Song(String t, String r) {
title = t;
rating = r;
}
public String getTitle(){
return title;
}
public String getRating(){
return rating;
}
// Need help here adding it to also compare by alphabetical title if songs have same ratings.
public int compareTo(Song s) {
return rating.compareTo(s.getRating());
}
The compareTo() method returns an int with the following values:
negative If thisObject < anotherObject
zero If thisObject == anotherObject
positive If thisObject > anotherObject
Check for value zero, meaning rating is same, then go for title comparison.
Sample Code , can be tweaked
public int compareTo(Song s) {
int val = rating.compareTo(s.getRating());
if(val == 0){
val = title.compareTo(s.getTitle());
}
return val;
}
Solution is to compare the name of the songs if their Rank is equal (and compareTo therefore returns 0) and return the result of the Second compare