Hashing
 Vejledende løsninger
1 Vi vil først se selve HashSet-klassen:
HashSet.java
public class HashSet {
  private int[] array;

  private final static int DELETED = -1;
  private final static int FREE = 0;

  public HashSet() {
    this( 10 );
  }

  public HashSet( int size ) {
    array = new int[ size ];

    clear();
  }

  public void add( int value ) {
    int i = findIndex( value );

    if ( i < 0 ) {
      i = hash( value );

      while ( true ) {
        if ( array[ i ] == FREE || array[ i ] == DELETED ) {
          array[ i ] = value;
          break; // eller return
        }

        i = inc( i );
      }
    }
  }

  public void delete( int value ) {
    int i = findIndex( value );

    if ( i >= 0 )
      array[ i ] = DELETED;
  }

  public boolean contains( int value ) {
    return findIndex( value ) >= 0;
  }

  public void clear() {
    for ( int i = 0; i < array.length; i++ )
      array[ i ] = FREE;
  }

  private int inc( int i ) {
    return ( i + 1 ) % array.length;
  }

  private int findIndex( int value ) {
    int i = hash( value );

    while ( true ) {
      if ( array[ i ] == value )
        return i;
      else if ( array[ i ] == FREE )
        // findes ikke
        return -1;

      i = inc( i );
    }
  }

  private int hash( int value ) {
    return value % array.length;
  }

  @Override
  public String toString() {
    StringBuffer sb = new StringBuffer();

    for ( int i = 0; i < array.length; i++ )
      if ( array[ i ] != FREE && array[ i ] != DELETED )
        sb.append( array[ i ] + " " );

    return sb.toString().trim();
  }
}
De to konstanter FREE og DELETED er måske ikke så nødvendige, og visse af udtrykkene kunne forkortes ved at anvende uligheder der i stedet sammenligner med 0, men de øger læsbarheden.
Kaldet af clear-metoden i konstruktoren er heller ikke nødvendig, men understreger at alle indgange i array'et initialt er sat til FREE (i.e. 0).
Problematikken omkring at starte forfra i array'et når man kommer ud for enden, er samlet i en service-metode: inc, der fremhæver løsningen med modulus.
Test-anvendelsen følger dernæst:
Main.java
public class Main {

  public static void main( String[] args ) {
    HashSet set = new HashSet();
    set.add( 19 );
    set.add( 29 );
    set.add( 39 );
    
    System.out.println( set );
    
    System.out.println( set.contains( 19 ) );
    System.out.println( set.contains( 29 ) );
    System.out.println( set.contains( 39 ) );
    System.out.println( set.contains( 5 ) );
    
    set.delete( 19 );
    
    System.out.println( set.contains( 19 ) );
    System.out.println( set.contains( 29 ) );
    System.out.println( set.contains( 39 ) );
    System.out.println( set.contains( 5 ) );
  }
}
29 39 19 
true
true
true
false
false
true
true
false
Udskriften er måske lidt svær at læse, da den næsten udelukkende består af true og false, men den demonstrerer at man kan indsætte og fjerne værdier fra mængden, samt teste for om elementer tilhører denne.