update

Author: Shell-thon

0x1A-hash_tables/100-main.c

@@ -0,0 +1,42 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "hash_tables.h"
+
+/**
+ * main - check the code for Holberton School students.
+ *
+ * Return: Always EXIT_SUCCESS.
+ */
+int main(void)
+{
+    shash_table_t *ht;
+    char *value, *key;
+
+    ht = shash_table_create(1024);
+    shash_table_set(ht, "y", "0");
+    shash_table_print(ht);
+    shash_table_set(ht, "j", "1");
+    shash_table_print(ht);
+    shash_table_set(ht, "c", "2");
+    shash_table_print(ht);
+    shash_table_set(ht, "b", "3");
+    shash_table_print(ht);
+    shash_table_set(ht, "z", "4");
+    shash_table_print(ht);
+    shash_table_set(ht, "n", "5");
+    shash_table_print(ht);
+    shash_table_set(ht, "a", "6");
+    shash_table_print(ht);
+    shash_table_set(ht, "m", "7");
+    shash_table_print(ht);
+    shash_table_print_rev(ht);
+
+
+    key = "y";
+    value = shash_table_get(ht, key);
+    printf("%s:%s\n", key, value);
+
+    shash_table_delete(ht);
+    return (EXIT_SUCCESS);
+}

0x1A-hash_tables/3-hash_table_set.c

@@ -1,75 +1,53 @@
 #include "hash_tables.h"
 
 /**
- * set_pair - mallocs a key/value pair to the hash table.
- * @node: a pointer to the hash table array node.
- * @key: the key, a string that cannot be empty.
- * @value: the value associated with the key, can be an empty string.
+ * hash_table_set - adds an element to the hash table
+ * @ht: hash table
+ * @key: key for hash table
+ * @value: value for key
  *
- * Return: 1 on success, 0 on error.
- */
-int set_pair(hash_node_t **node, const char *key, const char *value)
-{
-	*node = malloc(sizeof(hash_node_t));
-	if (*node == NULL)
-		return (0);
-	(*node)->key = malloc(strlen(key) + 1);
-	if ((*node)->key == NULL)
-		return (0);
-	(*node)->value = malloc(strlen(value) + 1);
-	if ((*node)->value == NULL)
-		return (0);
-	strcpy((*node)->key, key);
-	strcpy((*node)->value, value);
-	return (1);
-}
-
-/**
- * hash_table_set - adds an element to the hash table.
- * @ht: a pointer to the hash table array.
- * @key: the key, a string that cannot be empty.
- * @value: the value associated with the key, can be an empty string.
- *
- * Return: 1 on success, 0 on error.
+ * Return: 1 if it succeeded, 0 otherwise
  */
 int hash_table_set(hash_table_t *ht, const char *key, const char *value)
 {
+	hash_node_t *hnode = NULL, *collnode = NULL;
 	unsigned long int index;
-	hash_node_t *node;
+	char *valuedup = NULL, *keydup = NULL;
 
-	if (key == NULL)
+	if (!ht || !(ht->array) || !key || !key[0])
 		return (0);
+
 	index = key_index((unsigned char *)key, ht->size);
-	node = ht->array[index];
-	if (node == NULL)
-	{
-		if (set_pair(&node, key, value) == 0)
-			return (0);
-		node->next = NULL;
-		return (1);
-	}
-	while (node != NULL)
+	hnode = ht->array[index];
+	valuedup = strdup(value);
+	if (!valuedup)
+		return (0);
+
+	while (hnode != NULL)
 	{
-		if (strcmp(node->key, key) == 0)
+		if (!strcmp(hnode->key, key))
 		{
-			if (strcmp(node->value, value) == 0)
-				return (1);
-			free(node->value);
-			node->value = malloc(strlen(value) + 1);
-			if (node->value == NULL)
-				return (0);
-			strcpy(node->value, value);
+			free(hnode->value);
+			hnode->value = valuedup;
 			return (1);
 		}
-		node = node->next;
+		hnode = hnode->next;
 	}
-	if (node == NULL)
-	{
-		if (set_pair(&node, key, value) == 0)
-			return (0);
-		node->next = ht->array[index];
-		ht->array[index] = node;
-		return (1);
-	}
-	return (0);
+
+	hnode = ht->array[index];
+
+	collnode = malloc(sizeof(hash_node_t));
+	if (collnode == NULL)
+		return (free(valuedup), 0);
+
+	keydup = strdup(key);
+	if (!keydup)
+		return (free(valuedup), free(collnode), 0);
+
+	collnode->key = keydup;
+	collnode->value = valuedup;
+	collnode->next = hnode;
+	ht->array[index] = collnode;
+
+	return (1);
 }

0x1A-hash_tables/4-hash_table_get.c

@@ -1,32 +1,30 @@
 #include "hash_tables.h"
 
 /**
- * hash_table_get - retrieves a value associated with a key.
- * @ht: a pointer to the hash table array.
- * @key: the key, a string that cannot be empty.
+ * hash_table_get - retrieves a value associated with a key
+ * @ht: hash table
+ * @key: key for retrieving
  *
- * Return: the value associated with the key, or NULL if key can't be found.
+ * Return: 1 if it succeeded, 0 otherwise
  */
 char *hash_table_get(const hash_table_t *ht, const char *key)
 {
+	hash_node_t *hnode = NULL;
 	unsigned long int index;
-	hash_node_t *node;
 
-	if (ht == NULL)
-		return (NULL);
-	if (key == NULL)
+	if (!ht || !key || !key[0])
 		return (NULL);
+
 	index = key_index((unsigned char *)key, ht->size);
-	if (ht->array[index] == NULL)
-		return (NULL);
-	if (strcmp(ht->array[index]->key, key) == 0)
-		return (ht->array[index]->value);
-	node = ht->array[index];
-	while (node != NULL)
+	hnode = ht->array[index];
+
+	while (hnode != NULL)
 	{
-		if (strcmp(node->key, key) == 0)
-			return (node->value);
-		node = node->next;
+		if (!strcmp(hnode->key, key))
+			return (hnode->value);
+
+		hnode = hnode->next;
 	}
+
 	return (NULL);
 }

0x1A-hash_tables/5-hash_table_print.c

@@ -0,0 +1,32 @@
+#include "hash_tables.h"
+
+/**
+ * hash_table_print - prints a hash table
+ * @ht: hash table
+ *
+ * Return: No Return
+ */
+void hash_table_print(const hash_table_t *ht)
+{
+	hash_node_t *hnode;
+	int comma = 0;
+	unsigned long int i;
+
+	if (!ht)
+		return;
+
+	printf("{");
+	for (i = 0; i < ht->size; i++)
+	{
+		hnode = ht->array[i];
+		while (hnode)
+		{
+			if (comma)
+				printf(", ");
+			printf("'%s': '%s'", hnode->key, hnode->value);
+			hnode = hnode->next;
+			comma = 1;
+		}
+	}
+	printf("}\n");
+}

0x1A-hash_tables/6-hash_table_delete.c

@@ -1,25 +1,31 @@
 #include "hash_tables.h"
 
 /**
- * hash_table_delete - deletes a hash table.
- * @ht: the hash table.
+ * hash_table_delete - deletes a hash table
+ * @ht: hash table
+ *
+ * Return: No Return
+ *
  */
 void hash_table_delete(hash_table_t *ht)
 {
-	unsigned long int i = 0;
-	hash_node_t *node;
+	hash_node_t *hnode, *tmp;
+	unsigned long int i;
 
-	while (i < ht->size)
+	if (!ht)
+		return;
+
+	for (i = 0; i < ht->size; i++)
 	{
-		while (ht->array[i] != NULL)
+		hnode = ht->array[i];
+		while (hnode)
 		{
-			node = ht->array[i]->next;
-			free(ht->array[i]->key);
-			free(ht->array[i]->value);
-			free(ht->array[i]);
-			ht->array[i] = node;
+			tmp = hnode->next;
+			free(hnode->key);
+			free(hnode->value);
+			free(hnode);
+			hnode = tmp;
 		}
-		i++;
 	}
 	free(ht->array);
 	free(ht);