Thread: Help with Sort arrays

Hello,

I have a problem with arrays.

if i have an array of Integers (EX. Object[] tab = new Object[20];, tab[0] = new Integer(2); )

is possible to sort array's members with an iterator?

But i cant use any java defaut structure (school work)

i need to write a method toArray() that return an array of int in ascending order from an array of integer using an iterator (custom iterator because i cant use the iterator class methods)

My idea:

-> sort in ascending order with iterator array's members (tab[])
-> make a support array of int like int[] arraySup
-> copy elements to arraySup with intValue() method (i can use this)
-> return arraySup

Thanks for the help,

Best regards.

Read up on some sorting algorithms, such as Bubble Sort (Easy to implement and understand but slow O(n^2) ) or QuickSort much faster but more complex, there are many

Sorting algorithm - Wikipedia, the free encyclopedia

Chris

thanks for the help,

but i need an algorithm for implement the method toArray() of HashSet Class.

the problem is that my HashSet (custom class, not standard HashSet.java) is implemented with Arrays of int

Exemple

Set a = new HashSet();
a.put(2);

Can i sort (in ascendig order) HashSet elements with an iterator?

like this:

while(hasNext()){
...
...

This is an ex of my iter (but i dont know if its ok)

private class HashSetIter implements Iterator {

private int pos = 0;

public boolean hasNext(){

return pos < nsize; //nsize is a var that contains the number of elements in the HashSet

public Object next(){
if(pos < nsize){
return (int)tabSet[pos++]; //tabSet is the array of int that rapresent my Set
}else{
throw new NoSuchElementException();
}
}

public void remove(){
throw new UnsupportedOperationException();
}

}

But i hate iterators and i dont understand how i can use it.

Thanks for help,

best regards (and sorry for my school english )

Thank you for the answer.

There are some advices in my project text:

-the structure of classes cant be modified
-the iterators can use support structures
-the iterators must throw ConcurrentModificationException and NoSuchElementException
-the method remove() is not implemented
-Cant use java API structures.

Implementation of a Set with and array of int with max dimension limited by the free memory.

This is the interface give to me by teacher

public interface Set extends Iterable, Cloneable{
/**
* Set Empty
*/
void clear();
/**
* is the set empty?
* @return true if the set is empty, else return false.
*/
boolean isEmpty();
/**
* @return the number of elements inside the Set
*/
int size();
/**
* @return max number of elements inside the set, -1 if the set is empty
*/
int max();
/**
* @param x 
* @return 
*/
int nextTrue(int x);
/**
* add an int in to the set
* @param x the int to add.
* @return true if the int isnt already inside the set, else return falsei
* @exception IllegalArgumentException if x<0
*/
boolean put(int x);
/**
* 
* @return true if the int is already inside the set, else return false.
*/
boolean contains(int x);
/**
* remove an int from the set
* @param x
* @return true if the int is already inside the set, else return false
*/
boolean remove(int x);
/**
* Convert in String
* return a string with the elements of Set in ascending order in this form: [ 1 2 3 ]
* 
* @return the string
*/
String toString();
/**
* Convert in array
* return an array of int with the elements of set in ascendig order
* @return array of int
*/
int [] toArray();
/**
* clone
* @return a clone of set
* @throws CloneNotSupportedException
*/
Object clone() throws CloneNotSupportedException;
/**
* return an iterator for iter. the elements in ascending order
* the method remove isnt implemented
* @return iterator
*/
Iterator iterator();
/**
* Union
* add the elements of y in my set
* @param y the second set
*/
void union (Insieme y);
/**
* Intersection
* 
* @param y
*/
void intersection (Insieme y);
/**
* Difference
*
* @param y 
*/
void difference(Insieme y);
}

import java.util.*;
 
public class HashSet implements Set {
 
final private int address(int x, int l){
int hash = (new Integer(x)).hashCode();
return (hash & 0x7FFFFFFF) % l;
 
public void difference(Set y){
throw new UnsupportedOperationException();
}
 
public void intersection(Set y){
throw new UnsupportedOperationException();
}
 
public int max(){
throw new UnsupportedOperationException();
}
 
public int nextTrue(int x){
throw new UnsupportedOperationException();
}
 
public boolean remove(int x){
throw new UnsupportedOperationException();
}
 
public Object clone(){
throw new UnsupportedOperationException();
}
}