#include <bst.h>		// Include this if you want plain binary search tree based dictionary
#include <avl.h>		// Include this if you want AVL tree based dictionary

	// Inside of some function
	
	BisTree bis_dict;				// This is our Binary Search Tree dictionary
	AvlTree avl_dict;				// This is out AVL tree dictionary

	// We will use strings (char *) as keys and integers (int *) as associated value.
	// Here strcmp is the string comparison function for comparing keys.
	// Our string keys will be dynamically allocated, so we use 'free' from stdlib.h
	// as clean-up function for keys. This clean-up function will be called when we destroy our dictionary.
	// We also will insert dynamically allocated integers as value, so use 'free' to clean-up them
	// when we destroy this dictionary.
	
	avl_init(&avl_dict, strcmp, free, free);
	
	// OR, if you do not want your keys or values to be released automatically,
	// pass NULL as the value to the function pointer.
	
	avl_init(&avl_dict, strcmp, NULL, NULL);
	
	// OR, if you want to use the plain binary search tree based dictionary.
	
	bst_init(&bst_dict, strcmp, free, free);

	// Remember, keys or values are always inserted by their pointers.
	// We insert a pointer to the key element and a pointer to the value element.
	
	char *key = (char *) malloc(...);
	int *value = (int *) malloc(...);
	
	// Put some information into the key and value, such as *value = 18 or strcpy(key, "hello").
	
	int opval = avl_insert(&avl_dict, (const void *) key, (const void *) value);
	
	// OR, if you want to use the plain binary search tree based dictionary
	
	int opval = bst_insert(&avl_dict, (const void *) key, (const void *) value);

	// We look up for a key and retrive the associated value.
	// Here, 'value' variable is declared as 'int *value'.
	// We pass the 'address of value variable' as the 3rd argument,
	// So that the 'value' variable will point to the associated value after the lookup is finished.
	
	int *value = NULL;
	char *any_key = "any string here";
	opval = avl_lookup(&avl_dict, (const void *) any_key, (void **) &value);
	
	// Use 'bst_lookup' if you use a plain binary search tree
	
	// Check if we have found the key
	if (opval == 1) {
		// We have found the key. 'value' variable is pointing to the associated value.
		printf("%d\n", *((int *) value));
	}
	else {
		// We did not find the key because it does not exist.
		printf("Key not found\n");
	}

	int *new_value = (int *) malloc(...);
	*new_value = 35;
	
	// 'avl_reassign' changes the associated value to a new one for an existing key.
	// Use 'bst_reassign' if you use plain binary search tree.
	
	opval = avl_reassign(&avl_dict, (const void *) key, (const void *) new_value);

	char *key = "any key here";
	char *removed_key;
	int *removed_value;
	
	// Call 'avl_remove' function to remove a key and the value associated with it.
	// Call 'bst_remove' if you use a plain binary search tree based dictionary.
	// Upon removal, the pointer variable 'removed_key' and 'removed_value'
	// will point to the removed key element and removed value element respectively.
	
	int opval = avl_remove(&avl_dict, (const void *) key, (void **) &removed_key, (void **) &removed_value);
	
	if (opval == 0) {
		// Successfully removed. We can clean up the removed items.
		// Remember, we inserted dynamically allocated elements into the dictionary.
		// So de-allocation is necessary.
		
		printf("Removed key : %s\n", removed_key);
		printf("Removed value : %d\n", *removed_value);
		
		free((void *) removed_key);
		free((void *) removed_value);
	}

	// Use 'bst_size' instead if you use plain binary search tree
	
	int count = avl_size(&avl_dict);

	// When you no longer need the dictionay, remove it from the memory.
	// Call 'bst_destroy' instead if you use plain binary search tree.
	// This destruction function calls the clean-up functions passed into it
	// while initialization, so that all the keys and associated value elements
	// could be de-allocated from the memory while the dictionary is destroyed.
	
	avl_destroy(&avl_dict);
	
	// 'avl_dect' destroyed. Memory allocated by this dictionary is released.
	// All the keys and values which were dynamically allocated by user,
	// those are also released (cleaned up by 'free'
	// because we provided 'free' as clean-up function).

#include <avl.h>
#include <list.h>
#include <stdio.h>
#include <stdlib.h>

int main(void);
int compare_int(const void *arg1, const void *arg2);

int compare_int(const void *arg1, const void *arg2) {
	int *val1, *val2;
	
	val1 = (int *) arg1;
	val2 = (int *) arg2;
	return (*val1 - *val2);
}

int main(void) {
	List lstInt;
	ListElem *elem;
	int *pInt, index;
	
	list_init(&lstInt, free);
	
	elem = list_tail(&lstInt);
	for (index = 3; index >= -4; index--) {
		pInt = (int *) malloc(sizeof(int));
		*pInt = index;
		list_ins_next(&lstInt, elem, (const void *) pInt);
		elem = list_tail(&lstInt);
	}
	/* Current List: 3 2 1 0 -1 -2 -3 -4 */
	
	/* Sort Linked List */
	/* For more sort function, check out bst.h */
	avl_sort(&lstInt, compare_int);
	/* Sorted List: -4 -3 -2 -1 0 1 2 3 */
	
	printf("Sorted in ascending order. Printing...\n");
	elem = list_head(&lstInt);
	while (elem != 0) {
		pInt = (int *) list_data(elem);
		printf("%d ", *pInt);
		elem = list_next(elem);
	}
	
	list_destroy(&lstInt);
	return 0;
}