das ist mein erster Eintrag in diesem Forum, also habt ein bisschen Nachsicht mit mir falls etwas nicht funktionieren sollte.

Ich programmiere gerade eine Hashtabelle mit Double Hashing mein Problem ist allerdings es klappt irgendwie nicht so wie ich möchte.

1. Das erste Problem liegt in der Exception Defintion der min- & max-Methode
und zwar bekomme ich hier diese Fehlermeldung:
DoubleHashing.h: In member function ‘E DoubleHashing<E>::min() const [with E = TestKey]’:
testcfull.C:1206: instantiated from here
DoubleHashing.h:124: error: no type named ‘Exception’ in ‘class Container<TestKey>’

Dies kann aber meiner Meinung nach nicht sein, weil die Exception-Zeile:

[cpp]throw typename Container<E>::Exception("DoubleHashing<E>::min(): container empty");

[/cpp]

eigentlich in Ordnung sein sollte.

2. Mein zweites Problem findet sich in add:
Hier wird einfach niemals die erste Hashfunktion aufgerufen, sondern immer auf das Linear Probing zurück gegriffen.

3. Ich hoffe meine Frage wirkt nicht zu blöd, aber muss ich in der remove-Methode ebenfalls die Hashfunktionen durchlaufen oder kann ich einfach jeden Wert durchgehen?? Da bin ich mir wirklich nicht sicher.

4. In der apply Methode, also bei ascending und descending wird anscheinend auf einen unerwünschten Speicher im Hauptspeicher zugegriffen.

Kann mir jemand weiterhelfen, bzw. einen Tipp für zumindest eine der Problematiken geben?

PS: DoubleHashing.h habe ich selbst erstellt; Container.h wurde mir vorgegeben und wird nicht verändert, bzw. simpelest.cpp ist das zugehörige, ebenfalls vorgegebene Testprogramm.

Meine erstellte Klasse:

[cpp]
#ifndef DOUBLEHASHING_H
#define DOUBLEHASHING_H

#include <iostream>
#include "Container.h"

template <typename E>
class DoubleHashing : public Container<E> {

  class HashElements {
  public:
    unsigned int key;
    E element;
    int status;

    /*Konstruktor*/
    HashElements() : element() {
      key = 0;
      status = 0;
    }

    /*Destruktor*/
    ~HashElements() {/*delete [] element;*/}

    /*Hilfsfunktion fuer add*/
    void fill(const E a, unsigned int schluessel) {
      element = a;
      key = schluessel;
      status = 1;
    }

  };

  HashElements *value;
  size_t maxV; //maximal moegliche Eintraege
  size_t entries;//tatsaechliche Eintragsanzahl

  public:

    //TO DO: PROBLEMBESCHREIBUNG SIEHE METHODE
    using Container<E>::add; //add-Methode
    virtual void add (const E*e, size_t s);
    //void add_single (const E& e);
    void selectionSort(E* newHash, size_t traversePosition) const;
    virtual size_t apply (const Functor<E>&, Order=dontcare) const;

    //implemented
    virtual ~DoubleHashing<E>(); //Destruktor
    virtual std::ostream& print(std::ostream& o) const; //print
    virtual bool member (const E& e) const; //member-Methode
    using Container <E>::remove;
    virtual void remove(const E[], size_t);
    virtual E min() const;
    virtual E max() const;
     //void expand();
    //void swap(E& object1, E& object2) const;
    virtual size_t size() const {
      //liefert tatsaechliche Eintragszahl des Hashing-Verfahrens zurueck
      return entries;
    }

    virtual bool empty() const {
      if(entries!=0) {
        return false;
      }

      else {
        return true;
      }  
    }

    DoubleHashing<E>() {
      entries = 0;
      maxV = 7;
      value = new HashElements[7];
  }
};

  bool isprim(int number) {
    int temp = 2;
    for(; temp<number; ++temp) {
      if(number%temp == 0) {
        return false;
      }
    }

    return true;
  }

  int prim(int number) {
    int next = number+1;
    int last = number*2;
    while(next < last) {
        if(isprim(next) == true) {
          return next;
        }

        else {
          last++;
        }

        next++;
    } 
  }

      //Methode liefert kleinsten Wert des Hashing-Verfahrens zurueck
  template <typename E>
  E DoubleHashing<E>::min() const {
    E minimum;  
    if(entries!=0) {
        minimum = value[0].element;
        for(size_t i=0; i<maxV; i++) {
          if(minimum > value[i].element && value[i].status==1) {
            minimum = value[i].element;
          }
        }

        return minimum;
      }

      else {
        throw typename Container<E>::Exception("DoubleHashing<E>::min(): container empty");
      }
    } 

    //Methode liefert groessten Wert des Hashing-Verfahrens zurueck
    template <typename E>
    E DoubleHashing<E>::max() const {
      E maximum;
      if(entries==0) {
        throw Container<E>::Exception("DoubleHashing<E>::max(): container empty");
      }
      else {
        maximum = value[0].element;
        for(size_t i=0; i<maxV; i++) {
          if(value[i].element > maximum && value[i].status==1) {
            maximum = value[i].element;
          }
        }

        return maximum;
      }
    }

  template<typename E>
  DoubleHashing<E>::~DoubleHashing() {
    delete[]value;
  }

  //Problem: rehashing nach Vergroesserung
  //Problem_2: es werden nicht alle Werte hinzugefuegt
  template<typename E>
  void DoubleHashing<E>::add(const E e[], size_t len) {
    size_t newMax=maxV;
    size_t tempMax;
    unsigned int temp =0;
    HashElements *neu;

    if((entries+len) > ((newMax) * 0.7)) {
      HashElements *expand;
      do {
        newMax = prim(newMax);
      } while(newMax < ((entries+len)*10));

      expand = new HashElements[newMax];

      for(size_t i=0; i<maxV; ++i) {
          if(value[i].status==1) {
              temp = value[i].key % newMax;
              if(expand[temp].status==0) {
                expand[temp].fill(value[i].element, value[i].key);  
              }

              else {
                tempMax = newMax;
                for(size_t k=(temp+1); k<tempMax; ++k) {
                  if(expand[k].status == 0) {
                    expand[k].fill(value[i].element, value[i].key);
                    k=k+newMax;
                  }

                  if(k==newMax-1) {
                    k=0;
                    tempMax = temp;
                  }
                }
              }
            }

        }

      delete[] value;
      value = expand;
      maxV = newMax;
      }

      for(size_t j=0; j<len; ++j) {
        if(!member(e[j])) {
          temp = hashValue(e[j]) % maxV;
          neu = &value[temp];
          if(neu->status==0) {
            value[temp].fill(e[j],hashValue(e[j]));
            entries++;
          }

          else {
            for(size_t i=temp%maxV; i<maxV; ++i) {
              neu = &value[i];
              if(neu->status==0) {
                value[i].fill(e[j],hashValue(e[j]));
                i=i+maxV;
                entries++;
              }
            }
          }
        }
      }
    }

  template<typename E>
  bool DoubleHashing<E>::member(const E& e) const {
    unsigned int pos = hashValue(e) % maxV;
    unsigned int temp = maxV;
    for(unsigned int j=pos; j<temp; ++j) {
		if(value[j].status == 1) {
			if(value[j].element==e) {
				return true;
			}

			if(j==maxV-1) {
				temp = pos;
				j = 0;
			}
		}
    }
    return false;
  }

  template <typename E>
  std::ostream& DoubleHashing<E>::print(std::ostream& o) const {
    HashElements *eintrag;
    o<< "[values= ";
    for (size_t i=0; i<maxV; ++i) {
      eintrag = &value[i];
      o << ' ' << eintrag->element;
      eintrag = 0;
    }
    o <<" ] ";

    return o;
  }

  template<typename E>
  void DoubleHashing<E>::remove(const E e[], size_t s) {
    for(size_t i=0; i<s; i++) {
      for(size_t j=0; j<maxV; j++) {
        if(value[j].element == e[i] && value[j].status == 1) {
          value[j].status = 0;
          //value[j].element = 0;
          value[j].key = 0;
          --entries;
          break;
        }
      }
    }
  }

  template <typename E>
  size_t DoubleHashing<E>::apply(const Functor <E>& f, Order order) const {
    if(size()>0) {
      //selectionSort array
      E*newHash = new E[entries];
      size_t traversePosition = 0;
      size_t rc = 0;

      for(size_t i=0; i<maxV; i++) {
        //if(value[i].element>0) {
            newHash[traversePosition] = value[i].element;
            traversePosition++;
        //}
      }

      //ToDO: Fehler beim Sortieren  
      if(order==ascending) {
        selectionSort(newHash, traversePosition);
        for(size_t i=0; i<traversePosition; i++) {
          rc++;
          if(!f(newHash[i])) break;
        }
      }

      /*Problem: letzter Wert des Arrays wird nicht ausgegeben */
      if(order==descending) {
        selectionSort(newHash,traversePosition);
        //wenn i>=0 -> dann Zugriff auf nicht zugelassenen Hauptspeicher
        //wenn i>0 -> letzer Wert des Arrays wird nicht ausgegeben
        for(size_t i=traversePosition-1; i>0; i--) {
          rc++;
          if(!f(newHash[i])) break;
        }

      }

      if(order==dontcare) {
        for(size_t i=0; i<traversePosition; i++) {
          rc++;
          if(!f(newHash[i])) break;
        }
      }

      delete [] newHash;
      return rc;
    }
    return 0;
  }

  template <typename E>
  void DoubleHashing<E>::selectionSort(E* newHash, size_t traversePosition) const {
    //E minimum;
    size_t i, j, minIndex; 
    E temp;

    for(i=0; i<traversePosition-1; i++) {
      minIndex = i;
      for(j=i+1; j<traversePosition; j++) {
        if(newHash[minIndex] > newHash[j]) {
          minIndex = j;
        }
      }

      if(minIndex != i) {
        temp = newHash[i];
        newHash[i] = newHash[minIndex];
        newHash[minIndex] = temp;
      }
    }

   /* for(i=0; i<traversePosition-1; i++) {
      elementOne = i;
      minimum = newHash[i];

      for(j=i+1; j<traversePosition; j++) {
        if(minimum > newHash[j]) {
          elementTwo = j;
        }
      }
      swap(newHash[elementOne],newHash[elementTwo]);

    }
    */
  }

#endif
[/cpp]

Testprogramm:

// simpletest.C
 // 
 // UE Algorithmen und Datenstrukturen - SS 2012 Universitaet Wien
 // Container - Projekt
 // http://www.pri.univie.ac.at/courses/ADS/ss12/
 //Beim Kompilieren kann mittels Option -DETYPE=<typ> der Elementdatentyp des 
 //Containers festgelegt werden, also zB -DETYPE=Person (Defaulttyp ist int). 
 // Simples Testprogramm zur Ueberpruefung der Container-Funktionalitaet
 // Die Zeichenfolge Hashing ist in der ganzen Datei durch den Klassennamen 
 // der Datenstruktur zu ersetzen.
 // 
 // Der Elementdatentyp kann mit Compileroption -DETYPE=<typ> festgelegt werden,
 // also zb -DETYPE=std::string

 #include <iostream>
 #include <sstream>
 #include <fstream>
 #include <string>
 #include <cstring>
 #include <cstdlib>
 #include <cctype>
 #include "DoubleHashing.h"
 #include "Container.h"

 #ifndef ETYPE
 #define ETYPE int
 #endif

 const char helpstr[] = 
   "new ............................... create new Container\n"
   "delete ............................ delete Container\n"
   "add <key> [...] ................... add <key>(s) with Container::add( int )\n"
   "remove <key> [...] ................ remove <key>(s) with Container::remove( int )\n"
   "member <key> ...................... call Container::member( <key> )\n"
   "size .............................. call Container::size()\n"
   "empty ............................. call Container::empty()\n"
   "min ............................... call Container::min()\n"
   "max ............................... call Container::max()\n"
   "print ............................. print container with operator<<()\n"
   "apply [asc|desc|dontcare [<n>]] ... traverse container with PrintN functor\n"
   "trace ............................. toggle tracing on/off\n"
   "fadd <filename> ................... add values read from file <filename>\n"
   "fremove <filename> ................ remove values read from file <filename>\n"
   "radd [<n> [<seed>]] ............... add <n> random values, optionally reset generator to <seed>\n"
   "rremove [<n> [<seed>]] ............ remove <n> random values, optionally reset generator to <seed>\n"
   "quit .............................. quit program\n\n"
   "arguments surrounded by [] are optional\n";

 template <typename E>
 class PrintN : public Functor<E> {
   std::ostream& o;
   mutable int n;
 public:
   explicit PrintN( int n = 0, std::ostream& o = std::cout ) : o( o ), n( n ) { }
   explicit PrintN( std::ostream& o ) : o( o ), n( 0 ) { }
   bool operator()( const E& e ) const {
     o << e << ' ';
     return n <= 0 || --n;
   }
 };

 void setrandom( int seed ) { srand( seed ); }
 template <typename E> E nextrandom( ) { return E( rand( ) ); }

 // Template-Spezialisierungen fuer Klasse std::string

 template <> inline double doubleValue( const std::string& e ) { double rc = 0.; for (size_t i = e.length(); i--; ) rc /= 256., rc += e[i]; return rc; }
 template <> inline unsigned long hashValue( const std::string& e ) { unsigned long rc = 0; for (size_t i = 0; i < e.length(); ++i) rc = rc * 13 + e[i]; return rc; }
 template <> inline unsigned long ordinalValue( const std::string& ) { return 0; }
 template <> std::string nextrandom( ) {
   const char* start = helpstr + rand() % sizeof helpstr;
   while (!isalpha( *start )) if (*start) ++start; else start = helpstr;
   const char* end = start + 1;
   while (isalpha( *end )) ++end;
   return std::string( start, end - start );
 }

 // Klasse Person mit allen für die Verwendung als Container-Elementdatentyp noetigen Methoden und Funktionen

 class Person {
   std::string vorname;
   std::string nachname;
 public:
   Person() { }
   Person( std::string vorname, std::string nachname ) : vorname( vorname ), nachname( nachname ) { }
   bool operator==( const Person& p ) const { return vorname == p.vorname && nachname == p.nachname; }
   bool operator>( const Person& p ) const { return nachname > p.nachname || (nachname == p.nachname && vorname > p.vorname); }

   std::ostream& print( std::ostream& o ) const { return o << '[' << nachname << ", " << vorname << ']'; }
   std::istream& read( std::istream& i ) { return i >> vorname >> nachname; }
   friend double doubleValue<Person>( const Person& e );
   friend unsigned long hashValue<Person>( const Person& e );
   friend unsigned long ordinalValue<Person>( const Person& e );
 };

 inline std::ostream& operator<<( std::ostream& o, const Person& p ) { return p.print( o ); }
 inline std::istream& operator>>( std::istream& i, Person& p ) { return p.read( i ); }

 // Template-Spezialisierungen fuer Klasse Person

 template <> inline double doubleValue( const Person& e ) { return doubleValue( e.nachname ); }
 template <> inline unsigned long hashValue( const Person& e ) { return hashValue( e.nachname ); }
 template <> inline unsigned long ordinalValue( const Person& ) { return 0; }
 template <> Person nextrandom( ) { 
   return Person( nextrandom<std::string>(), nextrandom<std::string>() );
 }

 bool match( const std::string& s, const char * c ) {
   return c && s.length() <= std::strlen( c ) && s.compare( 0, s.length(), c, s.length() ) == 0;
 }

 int main() {

   Container<ETYPE>* c = 0;
   bool traceIt = false;
   std::cout.setf( std::ios_base::boolalpha );

   while (true) {
     if (traceIt) {
       if (c) {
         std::cout << std::endl << "container: " << *c;
       } else {
         std::cout << std::endl << "no container";
       }
     }
     std::cout << std::endl << "> ";

     std::string cmdline;
     if (!std::getline( std::cin, cmdline )) break;

     std::istringstream cmdstream( cmdline );
     std::string cmd;

     cmdstream >> cmd;

     try {
       if (cmd.length() == 0) {
       } else if (match( cmd, "quit" )) {
         break;
       } else if (match( cmd, "new" )) {
         if (c) {
           std::cerr << "container exists, 'delete' it first";
         } else {
           std::string typ;
           cmdstream >> typ;
           if (match( typ, "ContDynArray" ))
             c = new DoubleHashing<ETYPE>;
           else
             std::cout << "unknown container type " << typ;
         }
       } else if (match( cmd, "help" ) || cmd == "?") {
         std::cout << helpstr;
       } else if (match( cmd, "trace" )) {
         std::cout << "trace " << ((traceIt = !traceIt) ? "on" : "off");
       } else if (!c) {
         std::cout << "no container (use 'new')";
       } else {
         ETYPE key;
         if (match( cmd, "delete" )) {
           delete c;
           c = 0;
         } else if (match( cmd, "add" )) {
           while (cmdstream >> key) { c->add( key ); }
         } else if (match( cmd, "remove" )) {
           while (cmdstream >> key) { c->remove( key ); }
         } else if (match( cmd, "member" )) {
           cmdstream >> key;
           std::cout << "returns " << c->member( key );
         } else if (match( cmd, "size" )) {
           std::cout << "returns " << c->size( );
         } else if (match( cmd, "empty" )) {
           std::cout << "returns " << c->empty( );
         } else if (match( cmd, "min" )) {
           std::cout << "returns " << c->min( );
         } else if (match( cmd, "max" )) {
           std::cout << "returns " << c->max( );
         } else if (match( cmd, "print" )) {
           std::cout << *c;
         } else if (match( cmd, "apply" )) {
           int n = 0;
           std::string order = "dontcare";
           cmdstream >> order >> n;
           size_t rc = c->apply( PrintN<ETYPE>( n ), match( order, "ascending" ) ? ascending : match( order, "descending" ) ? descending : dontcare );
           std::cout << "\nreturns " << rc;
         } else if (match( cmd, "fadd" )) {
           std::string filename;
           cmdstream >> filename;
           std::ifstream keystream( filename.c_str() );
           while (keystream >> key) { c->add( key ); }
         } else if (match( cmd, "fremove" )) {
           std::string filename;
           cmdstream >> filename;
           std::ifstream keystream( filename.c_str() );
           while (keystream >> key) { c->remove( key ); }
         } else if (match( cmd, "radd" )) {
           int seed = -1, count = 1;
           cmdstream >> count >> seed;
           if (seed != -1) setrandom( seed );
           while (count-- > 0) c->add( nextrandom<ETYPE>() );
         } else if (match( cmd, "rremove" )) {
           int seed = -1, count = 1;
           cmdstream >> count >> seed;
           if (seed != -1) setrandom( seed );
           while (count-- > 0) c->remove( nextrandom<ETYPE>() );
         } else {
           std::cout << cmd << "? try 'help'";
         }
       }
     } catch (Container<ETYPE>::Exception& e) {
       std::cout << "Container::Exception " << e.what();
     } catch (std::exception& e) {
       std::cout << "Exception " << e.what();
     } catch (...) {
       std::cout << "OOPS!";
     }
   }
   return 0;
 }

Container-Header:

[code]
#ifndef CONTAINER_H
 #define CONTAINER_H

 // Container.h
 // 
 // UE Algorithmen und Datenstrukturen - SS 2012 Universitaet Wien
 // Container - Projekt
 // http://www.pri.univie.ac.at/courses/ADS/ss12/

 #include <iostream>
 #include <string>
 #include "DoubleHashing.h"

 enum Order { dontcare, ascending, descending };
 template <typename E> class Functor;

 template <typename E>
 class Container {
   Container<E>& operator=( const Container<E>& );
   Container<E>( const Container<E>& );
 public:
   class Exception;

   Container<E>( ) { }
   virtual ~Container<E>( ) { }

   virtual void add( const E& e ) { add( &e, 1 ); }
   virtual void add( const E e[], size_t s ) = 0;

   virtual void remove( const E& e ) { remove( &e, 1 ); }
   virtual void remove( const E e[], size_t s ) = 0;

   virtual bool member( const E& e ) const = 0;
   virtual size_t size( ) const = 0;

   //nicht implementiert
   virtual bool empty( ) const { return false; } //nicht implementiert

   //nicht implementiert
   virtual size_t apply( const Functor<E>& f, Order order = dontcare ) const { return 0; }

   virtual E min( ) const = 0;
   virtual E max( ) const = 0;

   virtual std::ostream& print( std::ostream& o ) const = 0;
 };

 template <typename E>
 inline std::ostream& operator<<( std::ostream& o, const Container<E>& c ) { return c.print( o ); }

 template <typename E>
 class Container<E>::Exception : public std::exception {
   std::string msg;
 public:
   explicit Exception( const std::string& msg ) throw() : msg( msg ) {}
   virtual ~Exception() throw() {}
   virtual const char * what() const throw() { return msg.c_str(); }
 };

 template <typename E>
 class Functor {
 public:
   virtual bool operator( )( const E& e ) const = 0;
   virtual ~Functor( ) {}
 };

 template <typename E> inline unsigned long hashValue( const E& e ) { return (unsigned long) e * 47114711; }
 template <typename E> inline double doubleValue( const E& e ) { return double( e ); }
 template <typename E> inline unsigned long ordinalValue( const E& e ) { return (unsigned long) e; }

 #endif //CONTAINER_H

[/code]

Als an min() und max() arbeite ich gerade Container und simpelest wurden verändert und das wusste ich leider bisher nicht, allerdings geht es hier "nur" um das Exception Handling, was ich mittlerweile auch erledigt habe.

Mein größtes und wichtigstes Problem liegt in der add-Methode. Kann mir jemand erklären, was ich falsch mache, bzw. warum er immer nur auf die zweite Hashfunktion zu greift?

Ich bin wirklich schon verzweifelt.
Danke für eure Hilfe

class Exception : public Container<E>::Exception {
  public:

    virtual const char* what() const throw() {
      return "DoubleHashing: container empty";

    }
  };

Die Methoden min() und max() sollen darauf zugreifen, allerdings tun sie dass nicht, sondern werfen mir die Fehlermeldung, dass kein geeigneter Standardkonstruktur verfügbar ist. Wenn ich diesen in der Exception Klasse definiere funktioniert es auch nicht. Weiß jemand Rat?

template <typename E>
  E DoubleHashing<E>::max( ) const {
    if (this->empty()) throw Exception( );
    E rc = value[0].element;
    for (size_t i = 1; i < maxV; ++i) {
      if (value[i].element > rc) rc = value[i].element;
    }
  return rc;
}

  template <typename E>
  E DoubleHashing<E>::min( ) const {
   if (this->empty()) throw Exception( );
    E rc = value[0].element;
    for (size_t i = 1; i < maxV; ++i) {
      if (rc > value[i].element) rc = value[i].element;
    }
    return rc;
  }

Weiß jemand Rat?

Ja. Nicht alle Exception-Klassen einfach nur "Exception" nennen. Du sagst "Exception" und meinst die Klasse, die du beschrieben hast. Der Compiler denkt aber vermutlich an irgendeine andere Klasse, die "Exception" heißt.

aber mit viel überlegen geht das schon!;)

SeppJ schrieb:

Den Code kenn ich doch! Wurde pepschi rausgeworfen und nun musst du sein Projekt übernehmen?

class CDAEmptyException : public ContainerException{
public:
  virtual const char * what() const throw () { return "DoubleHashing: container empty"; }
};

 template <typename E>
E DoubleHashing<E>::min( ) const {
  if (this->empty()) throw CDAEmptyException();
  else {
    E rc;
    for(size_t j=0; j < maxV; ++j) {
      if(value[j].element > -1) {
        rc = value[j].element;
        break;
      }
    }
    for (size_t i = 1; i < maxV; ++i) {
      if (rc > value[i].element && value[i].element > -1) rc = value[i].element;
    }
    return rc;
  }
}

template <typename E>
E DoubleHashing<E>::max( ) const {
  if (this->empty()) throw CDAEmptyException( );
  else {
    E rc;
    for(size_t j=0; j < maxV; ++j) {
      if(value[j].element > -1) {
        rc = value[j].element;
        break;
      }
    }
    for (size_t i = 1; i < maxV; ++i) {
      if (value[i].element > rc) rc = value[i].element;
    }
    return rc;
  }
}

@Pepschi schrieb: aber mit viel überlegen geht das schon!;)

Sorry, aber der Ratschlag ist bei mir echt fehl am Platz. Glaub mir es gibt, wahrscheinlich keinem der mehr bei dieser Projektarbeit überlegt hat, als ich. Denn beim letzten Versuch hatte ich eine vollständige Implementierung für einen Heap mit Heapsort fertig und einen abschließenden Success. Ich war so dumm einen meiner Kolleginen meine fertige Arbeit vor dem Abgabegespräch zu geben und sie ist zwei Stunden vor mir zum Abgabegespräch gegangen. Sie hat mein File abgegeben und der Prof meinte dann zu mir man könne nicht beweisen, wer von wem plagiert hat, obwohl ich es definitiv beweisen hätte können. Sie wurde positiv benotet und mir wurde gerade noch kein Plagiat gegeben. Also sorry, dass mich der Spruch nicht gerade erfreut.

Vonwegen Plagiat, also da hätte ich Stunk gemacht und "verlangt" dass die Kollegin zumindest auch ne 0 bekommt.

da können wanek und co schon sehr böse sein!

verstehe deinenärger aber mein comment war nicht an dich gerichtet!

wo liegt bei dir der fehler also in deinem programm?!

ich hänge gerade beim quicksort da ich gerade zu blöd bin mein array in den quicksort also in die funktion zukopieren und ein neues array zu erstellen! kannst du mir da vlt weiter helfen?! helfe auch dir gerne weiter!

lg

tinkabell schrieb:

Gut, die Klasse für das Exception Handling und die beiden Methode habe ich verändert:

class CDAEmptyException : public ContainerException{
public:
  virtual const char * what() const throw () { return "DoubleHashing: container empty"; }
};

 template <typename E>
E DoubleHashing<E>::min( ) const {
  if (this->empty()) throw CDAEmptyException();
  else {
    E rc;
    for(size_t j=0; j < maxV; ++j) {
      if(value[j].element > -1) {
        rc = value[j].element;
        break;
      }
    }
    for (size_t i = 1; i < maxV; ++i) {
      if (rc > value[i].element && value[i].element > -1) rc = value[i].element;
    }
    return rc;
  }
}
 
template <typename E>
E DoubleHashing<E>::max( ) const {
  if (this->empty()) throw CDAEmptyException( );
  else {
    E rc;
    for(size_t j=0; j < maxV; ++j) {
      if(value[j].element > -1) {
        rc = value[j].element;
        break;
      }
    }
    for (size_t i = 1; i < maxV; ++i) {
      if (value[i].element > rc) rc = value[i].element;
    }
    return rc;
  }
}

@Pepschi schrieb: aber mit viel überlegen geht das schon!;)

Sorry, aber der Ratschlag ist bei mir echt fehl am Platz. Glaub mir es gibt, wahrscheinlich keinem der mehr bei dieser Projektarbeit überlegt hat, als ich. Denn beim letzten Versuch hatte ich eine vollständige Implementierung für einen Heap mit Heapsort fertig und einen abschließenden Success. Ich war so dumm einen meiner Kolleginen meine fertige Arbeit vor dem Abgabegespräch zu geben und sie ist zwei Stunden vor mir zum Abgabegespräch gegangen. Sie hat mein File abgegeben und der Prof meinte dann zu mir man könne nicht beweisen, wer von wem plagiert hat, obwohl ich es definitiv beweisen hätte können. Sie wurde positiv benotet und mir wurde gerade noch kein Plagiat gegeben. Also sorry, dass mich der Spruch nicht gerade erfreut.