add last tasks

Author: GamilaCoding

0x1A-hash_tables/2-key_index.c

@@ -0,0 +1,15 @@
+#include "hash_tables.h"
+
+/**
+ * key_index - Get the index at which a key/value
+ *      pair should be stored in array of a hash table.
+ * @key: The key to get the index of.
+ * @size: The size of the array of the hash table.
+ *
+ * Return: The index of the key.
+ * Description: Uses the djb2 algorithm.
+ */
+unsigned long int key_index(const unsigned char *key, unsigned long int size)
+{
+	return (hash_djb2(key) % size);
+}

0x1A-hash_tables/3-hash_table_set.c

@@ -0,0 +1,53 @@
+#include "hash_tables.h"
+
+/**
+ * hash_table_set - Add or update an element in a hash table.
+ * @ht: A pointer to the hash table.
+ * @key: The key to add - cannot be an empty string.
+ * @value: The value associated with key.
+ *
+ * Return: Upon failure - 0.
+ *         Otherwise - 1.
+ */
+int hash_table_set(hash_table_t *ht, const char *key, const char *value)
+{
+	hash_node_t *new;
+	char *value_copy;
+	unsigned long int index, i;
+
+	if (ht == NULL || key == NULL || *key == '\0' || value == NULL)
+		return (0);
+
+	value_copy = strdup(value);
+	if (value_copy == NULL)
+		return (0);
+
+	index = key_index((const unsigned char *)key, ht->size);
+	for (i = index; ht->array[i]; i++)
+	{
+		if (strcmp(ht->array[i]->key, key) == 0)
+		{
+			free(ht->array[i]->value);
+			ht->array[i]->value = value_copy;
+			return (1);
+		}
+	}
+
+	new = malloc(sizeof(hash_node_t));
+	if (new == NULL)
+	{
+		free(value_copy);
+		return (0);
+	}
+	new->key = strdup(key);
+	if (new->key == NULL)
+	{
+		free(new);
+		return (0);
+	}
+	new->value = value_copy;
+	new->next = ht->array[index];
+	ht->array[index] = new;
+
+	return (1);
+}

0x1A-hash_tables/4-hash_table_get.c

@@ -0,0 +1,29 @@
+#include "hash_tables.h"
+
+/**
+ * hash_table_get - Retrieve the value associated with
+ *                  a key in a hash table.
+ * @ht: A pointer to the hash table.
+ * @key: The key to get the value of.
+ *
+ * Return: If the key cannot be matched - NULL.
+ *         Otherwise - the value associated with key in ht.
+ */
+char *hash_table_get(const hash_table_t *ht, const char *key)
+{
+	hash_node_t *node;
+	unsigned long int index;
+
+	if (ht == NULL || key == NULL || *key == '\0')
+		return (NULL);
+
+	index = key_index((const unsigned char *)key, ht->size);
+	if (index >= ht->size)
+		return (NULL);
+
+	node = ht->array[index];
+	while (node && strcmp(node->key, key) != 0)
+		node = node->next;
+
+	return ((node == NULL) ? NULL : node->value);
+}

0x1A-hash_tables/5-hash_table_print.c

@@ -0,0 +1,39 @@
+#include "hash_tables.h"
+
+/**
+ * hash_table_print - Prints a hash table.
+ * @ht: A pointer to the hash table to print.
+ *
+ * Description: Key/value pairs are printed in the order
+ *              they appear in the array of the hash table.
+ */
+void hash_table_print(const hash_table_t *ht)
+{
+	hash_node_t *node;
+	unsigned long int i;
+	unsigned char comma_flag = 0;
+
+	if (ht == NULL)
+		return;
+
+	printf("{");
+	for (i = 0; i < ht->size; i++)
+	{
+		if (ht->array[i] != NULL)
+		{
+			if (comma_flag == 1)
+				printf(", ");
+
+			node = ht->array[i];
+			while (node != NULL)
+			{
+				printf("'%s': '%s'", node->key, node->value);
+				node = node->next;
+				if (node != NULL)
+					printf(", ");
+			}
+			comma_flag = 1;
+		}
+	}
+	printf("}\n");
+}

0x1A-hash_tables/6-hash_table_delete.c

@@ -0,0 +1,30 @@
+#include "hash_tables.h"
+
+/**
+ * hash_table_delete - Deletes a hash table.
+ * @ht: A pointer to a hash table.
+ */
+void hash_table_delete(hash_table_t *ht)
+{
+	hash_table_t *head = ht;
+	hash_node_t *node, *tmp;
+	unsigned long int i;
+
+	for (i = 0; i < ht->size; i++)
+	{
+		if (ht->array[i] != NULL)
+		{
+			node = ht->array[i];
+			while (node != NULL)
+			{
+				tmp = node->next;
+				free(node->key);
+				free(node->value);
+				free(node);
+				node = tmp;
+			}
+		}
+	}
+	free(head->array);
+	free(head);
+}