macht es sinn den key als array von pointer anzulegen...oder besser std::string?

beim aufrufen von add sollte ich wenn falls der hash index belegt ist, so lange suchen bis ich status_arr == 0 oder status_arr == -1 finde?

/* Hashtable */
class hashtable
{
private:
	char **key_arr;
	unsigned int *value_arr;
	int *status_arr;
	unsigned int length;

private:
	unsigned int hash(const char *key)
	{
		int sum = 0;

		for(unsigned int i = 0; i < strlen(key); i++)
		{
			sum = sum + static_cast<unsigned int>(key[i]);
		}

		return sum = sum % length;
	}

public:
	hashtable(int n): length(n)
	{
		value_arr = new unsigned int[n];
		status_arr = new int[n];
		key_arr = new char*[n];

		for(unsigned int i = 0; i < n; i++)
		{
			status_arr[i] = 0;
		}
	}

	void add(const char *key, const unsigned int &value)
	{
		unsigned int hash_index = hash(key);

		if(status_arr[hash_index] != 1)
		{
			key_arr[hash_index] = const_cast<char*>(key);
			value_arr[hash_index] = value;
			status_arr[hash_index] = 1;
		}
		else 
		{
			hash_index++;
			key_arr[hash_index] = const_cast<char*>(key);
			value_arr[hash_index] = value;
			status_arr[hash_index] = 1;
		}
	}

	unsigned int item(const char *key)
	{
		unsigned int hash_index = hash(key);
		return value_arr[hash_index];
	}

	unsigned int remove(const char *key)
	{
		unsigned int hash_index = hash(key);
		value_arr[hash_index] = 0;
		status_arr[hash_index] = -1;
	}

	~hashtable()
	{
		delete[] value_arr;
		delete[] key_arr;
	}
};

hi,

macht es sinn den key als array von pointer anzulegen...oder besser std::string?

beim aufrufen von add sollte ich wenn falls der hash index belegt ist, so lange suchen bis ich status_arr == 0 oder status_arr == -1 finde?

/* Hashtable */
class hashtable
{
private:
	char **key_arr;
	unsigned int *value_arr;
	int *status_arr;
	unsigned int length;

private:
	unsigned int hash(const char *key)
	{
		int sum = 0;
		
		for(unsigned int i = 0; i < strlen(key); i++)
		{
			sum = sum + static_cast<unsigned int>(key[i]);
		}

		return sum = sum % length;
	}

public:
	hashtable(int n): length(n)
	{
		value_arr = new unsigned int[n];
		status_arr = new int[n];
		key_arr = new char*[n];

		for(unsigned int i = 0; i < n; i++)
		{
			status_arr[i] = 0;
		}
	}

	void add(const char *key, const unsigned int &value)
	{
		unsigned int hash_index = hash(key);

		if(status_arr[hash_index] != 1)
		{
			key_arr[hash_index] = const_cast<char*>(key);
			value_arr[hash_index] = value;
			status_arr[hash_index] = 1;
		}
		else 
		{
			hash_index++;
			key_arr[hash_index] = const_cast<char*>(key);
			value_arr[hash_index] = value;
			status_arr[hash_index] = 1;
		}
	}

	unsigned int item(const char *key)
	{
		unsigned int hash_index = hash(key);
		return value_arr[hash_index];
	}

	unsigned int remove(const char *key)
	{
		unsigned int hash_index = hash(key);
		value_arr[hash_index] = 0;
		status_arr[hash_index] = -1;
	}

	~hashtable()
	{
		delete[] value_arr;
		delete[] key_arr;
	}
};

Ganz schlechte Implementierung:
1. schlechte Hashfunktion, da der Wert den Rahmen sprengen könnte besser ist XOR!
2. XOR ist deswegen auch besser, weil man ähnliche Hashwerte gerne weitgestreut bekommen möchte (nicht wichtig, aber meistens ein Gütekriterium) 'hallo' und 'halol' haben gleiche Werte bei dir!
3. NIEMALS CONST CAST!!!!!!!!!!!!!
4. wenn du ein char übergibst musst du es entweder ganz kopieren aber nicht nur den pointer! Folgender Aufruf erzeugt einen Pointer der dann ins Nirwana zeigt tbl.add("Hallo", 5);
5. die item und remove methode muss überprüfen ob der key wirklich matched, oder nur ein verschobenes item wegen überlauf ist!!!!!!!

Ich denke, dass du bevor du mit Hashing arbeiten kannst erstmal noch ein paar Stunden in Pointer, Referenzen, new, malloc, etc investieren solltest! Hier fehlen die Basics noch finde ich!
Deine Variante würde schon gehen, aber wenn du const übergibst, müssen die auch const gespeichert werden! Geht alles, ist halt komisch.

Besser wäre, wenn du Key-Objekte übergibst, die sich selber um die Speicherung kümmern! Vielleicht sogar Objekte mit RefCounter. Dann kannst du deine Hashtable gleich als template definieren!

/* Hashtable */
template<class T>
class hashtable
{
private:
struct item
{
item():init(false){}
T item;
char *key;
bool init;
};

union hsh
{
unsigned int h;
char bytes[sizeof(unsigned int)];
};

vector<item> m_table;

private:
unsigned int hash(const char *key)
{

  hsh h;
  h.h = 0;

  for(unsigned int i = 0; i < strlen(key); i++)
    h.bytes[i%sizeof(unsigned int)] ^= key[i];

  return hsh.h;
}

};

3. NIEMALS CONST CAST!!!!!!!!!!!!!

So n Blödsinn.

PhilippHToner schrieb:

3. NIEMALS CONST CAST!!!!!!!!!!!!!

So n Blödsinn.

Jetzt weiß ich wieso dich die Leute hier nicht mögen :-D! Keine Ahnung vom Hashing wahrscheinlich, aber const casten

const char str[100]="stupid";

strcpy(const_cast<char *>(str), "God");
cout << "I'm " << str;

class hashtable
{
private:
	string *key_arr;
	unsigned int *value_arr;
	int *status_arr; // contains the status of the table at index pos: deleted, empty or used
	unsigned int length;

private:
	unsigned int hash(string key)
	{
		int sum = 0;

		for(unsigned int i = 0; i < key.length(); i++)
		{
			sum = sum + static_cast<unsigned int>(key[i]);
		}

		return sum = key.length() % length;
	}

public:
	hashtable(int n): length(n)
	{
		value_arr = new unsigned int[n];
		status_arr = new int[n];
		key_arr = new string[n];

		for(unsigned int i = 0; i < n; i++)
		{
			status_arr[i] = 0;
		}
	}

	void add(const string &key, const unsigned int &value)
	{
		unsigned int hash_index = hash(key);
		unsigned int j = 0;

		if(status_arr[hash_index] != 1)
		{
			key_arr[hash_index] = key;
			value_arr[hash_index] = value;
			status_arr[hash_index] = 1;
		}
		else
		{
			do {
				hash_index ++;
				hash_index = hash_index % length;

				if(status_arr[hash_index] != 1)
				{
					key_arr[hash_index] = key;
					value_arr[hash_index] = value;
					status_arr[hash_index] = 1;

					return;
				}
				else
				{
					j++;
				}
			} while(j < length);

			throw("Error collision");
		}
	}

	bool contains(const string &key)
	{
		unsigned int hash_index = hash(key);
		if(status_arr[hash_index] == 1) 
		{
			return true;
		}
		return false;
	}

	unsigned int item(const string &key)
	{
		unsigned int hash_index = hash(key);
		if(status_arr[hash_index] == 1) 
		{
			return value_arr[hash_index];
		}
		throw("Error calling item");
	}

	bool remove(const string &key)
	{
		if(contains(key))
		{
			unsigned int hash_index = hash(key);
			value_arr[hash_index] = 0;
			status_arr[hash_index] = -1;

			return true;
		}

		return false;
	}

	~hashtable()
	{
		delete[] value_arr;
		delete[] key_arr;
		delete[] status_arr;
	}
};

int main()
{
	hashtable h(5);
	h.add("Hugo", 5);
	h.add("Gerald", 10);
	h.add("Birgit", 11);
	h.add("Birgig", 11);
	h.add("Birgia", 11);

	cout << h.item("Birgit") << endl;
	cout << h.item("Birgig") << endl;
	cout << h.item("Birgia") << endl;

	h.remove("Birgit");

	cout << h.item("Birgig") << endl;
	cout << h.item("Birgia") << endl;

        return 0;
}

Deine Aussage ist generell einfach Mist, da es Anwendungsfälle für const_cast gibt.

knivil schrieb:

Ich gestehe, ich habe auch schon const_cast benutzt.

Wozu braucht ihr das, außer für fremde Libs die nicht const correct sind?

314159265358979 schrieb:

Deine Aussage ist generell einfach Mist, da es Anwendungsfälle für const_cast gibt.

knivil schrieb:

Ich gestehe, ich habe auch schon const_cast benutzt.

Wozu braucht ihr das, außer für fremde Libs die nicht const correct sind?

Das taucht zum Beispiel gerne mal auf, wenn man einen Iterator und einen Const_Iterator selber implementiert, aber nicht alles doppelt schreiben möchte.

hi,
ich weiss die hash funktion ist nicht gerade geeignet hier...aber was mache ich wenn die hash funktion einen hash liefert und dieser schon in der tabelle vorhanden ist? wie finde ich das richtig element wieder?

Alles schreiben nur noch über den const_cast schmarrn, zurück zu dir:

Also es ist ganz normal, dass es zu einer sog. Kollision kommt. Du möchtest N Elemente auf M abbilden. Für N <= M ist das theoretisch möglich, doch nur wenn es eine Hashfunktion gibt, die das in konstanter Laufzeit schafft, also unabhängig von N ist. Es fängt schonmal so an, dass die Elemente vielleicht gar nicht durchnummeriert sind und keine direkt (ideale) Abbildung ohne Kollision möglich ist. Deshalb wählt man ein M relativ größer als N (wobei die Größe davon abhängig ist, wie wahrscheinlich man sich eine nicht konstante Laufzeit doch erlauben kann). Also wenn du so willst ist Hashing zu einem Prozentsatz konstant und zu einem Prozentsatz Laufzeit linear (Überlaufstrategie). Im Grunde genommen instabil.

Deshalb ist die richtige Wahl einer guten Hashfunktion so wichtig. Und nun zurück zu deiner Frage: Bei einer Kollision kommt die Überlaufstrategie zum Einsatz. Es gibt verschiedene Strategien, aber für gute Hashfunktion und großen M kann man sich eine lineare Suche erlauben. Z.B. fügt man ein Element bei einer Kollision in den nächste freie Feld. Es gibt verschiedene Hasingmethoden, du musst hier abwägen, was du brauchst! Offenes Hashing, geschlossenes Hashing, distributed Hashing, uvm. einfach googlen!

Dadurch, dass die Hashfunktion auch ein anderes Element auf den gleichen HAshwert abbilden kann, musst du immer nochmal den direkten Test machen ob es wirklich das Element ist, denn Hashing hilft die genau genommen nur über einen Zugriffspfad, aber sagt dir nie 100% ob es wirklich das ELement ist!