Linked list updated with new functions.

Added list_copy makes deep copy of list.  Returns separate copy of the
not a new pointer to the old list.

Added list_print display contents of list to stdout. The list uses pointers
to void so the printout only includes the addresses of the data payload
and not the contents.

Function list_get_num returns pointer to node by number. Number zero
is the address of the head node.

Function list_node_swap reverses the data payload of two nodes.

Function list_reverse reverses the linked list payload. It should
be noted that the addresses of the nodes themselves are modified
during this operation.

Hash functions have been removed from unit tests. Hash functions not
complete in this revision and should not be used.

Author: steven-schronk

lib_hash.c

@@ -44,9 +44,24 @@ Hash hash_new_prime(int len)
 	return h;
 }
 
+int hash_data(void *data, int num, size_t size)
+{
+	int slot = 0;
+	while(num >= 0)
+	{
+		/* slot += (void *) (data) + (num * size); */
+		slot += (int)data + size * num;
+		num--;
+	}
+	return slot;
+}
+
 int hash_insert(Hash h, void * data, size_t length)
 {
+	int slot;
 	assert(data != NULL);
+	/*slot = hash_data(data, length);
+	if(h[slot]->data == NULL) *//* insert data in first node */;
 
 	return 0;
 }
@@ -86,29 +101,3 @@ void hash_delete(Hash h)
 {
 	free(&h);
 }
-
-
-/*
-
-int main()
-{
-	int j, loc, distinct, key, num[N + 1];
-	FILE * in = fopen("numbers.in", "r");
-	for(j = 1; j <= N; j++)
-		num[j] = Empty;
-	distinct = 0;
-	while(fscanf(in, "%d", &key) == 1) {
-		loc = loc % N + 1;
-		if(num[loc] == Empty) {
-			if(distinct == MaxNumbers) {
-				printf("\nTable Full: %d not added\n", key);
-				exit(1);
-			}
-			num[loc] = key;
-			distinct++;
-		}
-	}
-	printf("\nThere are %d distinct numbers\n", distinct);
-	fclose(in);
-}
-*/

lib_ll.c

@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <stdbool.h>
@@ -17,7 +18,10 @@ List_Head *list_new(void)
 
 void list_delete(List_Head *pHead)
 {
-	List_Node *pTemp = pHead->pNext;
+	List_Node *pTemp;
+	assert(pHead != NULL);
+	if(pHead->count == 0) { return; }
+	pTemp = pHead->pNext;
 	while(pTemp->pNext != NULL)
 	{
 		pTemp = pTemp->pNext;
@@ -50,11 +54,6 @@ List_Node *list_tail(List_Head *pHead)
 	return pTemp;
 }
 
-void list_print(List_Head *pHead)
-{
-	printf("Count: %d\n", pHead->count);
-}
-
 List_Node *list_ins_head(List_Head *pHead)
 {
 	List_Node *pTemp = pHead->pNext;
@@ -187,6 +186,7 @@ int list_rm_node(List_Head *pHead, List_Node *pNode)
 	return 1;
 }
 
+
 int list_rm_before(List_Head *pHead, List_Node *pNode)
 {
 	List_Node *pPrev = list_prev_node(pHead, pNode);
@@ -195,9 +195,86 @@ int list_rm_before(List_Head *pHead, List_Node *pNode)
 	return list_rm_node(pHead, pPrev);
 }
 
+int list_copy(List_Head *pDest, List_Head *pSrc)
+{
+	List_Node *pNewNode = NULL, *pSrcNode = NULL;
+	assert(pDest != NULL && pSrc != NULL);
+	pSrcNode = pSrc->pNext; /* first node from source */
+	if(pSrcNode == NULL) return 0; /* empty source list */
+	while (pSrcNode->pNext != NULL)
+	{
+		pNewNode = list_ins_tail(pDest);
+		if(pNewNode == NULL) { return 1; }
+		pNewNode->pData = pSrcNode->pData; /* copy data */
+		pSrcNode = pSrcNode->pNext; /* move to next pointer */
+	}
+	return 0;
+}
+
+void list_print(List_Head *pHead)
+{
+	int i = 0;
+	List_Node *temp = NULL;
+	assert(pHead != NULL);
+	printf("\n");
+	if(pHead->count == 0)
+		printf("Empty List\n");
+	else {
+		temp = pHead->pNext;
+		do {
+			printf("List Item: %d -> Data: %p\n", i, (void *)temp);
+			temp = temp->pNext;
+			i++;
+		} while (temp != NULL);
+	}
+}
+
+List_Node *list_get_num(List_Head *pHead, int count)
+{
+	int i = 1;
+	List_Node *pNode;
+	assert(count >= 0);
+	assert(pHead != NULL);
+	if(count == 0) { return pHead->pNext; }
+	if(pHead->count == 0) { return NULL; }
+	pNode = pHead->pNext;
+	if(count == 1) { return pNode; }
+	while(i < count)
+	{
+		if(pNode->pNext == NULL) { return NULL; }
+		pNode = pNode->pNext;
+		i++;
+	}
+	return pNode;
+}
+
+int list_node_swap(List_Node *pPrev, List_Node *pCurr)
+{
+	List_Node* pTemp = NULL;
+	assert(pCurr != NULL && pPrev != NULL);
+	pTemp = pCurr->pNext;
+	pCurr->pNext = pPrev->pNext;
+	pPrev->pNext = pTemp;
+	return 0;
+}
+
+List_Head *list_reverse(List_Head *pHead)
+{
+	List_Head *newList = list_new();
+	assert(pHead != NULL);
+	while(pHead->count > 0)
+	{
+		list_ins_head_data(newList, pHead->pNext->pData);
+		list_rm_node(pHead, pHead->pNext);
+	}
+	list_delete(pHead);
+	return newList;
+}
+
 void list_clear(List_Head *pHead)
 {
 	List_Node *pTemp = pHead->pNext;
+	assert(pHead != NULL);
 	if(pTemp != NULL)
 	{
 		while(pTemp->pNext != NULL)
@@ -213,7 +290,6 @@ void list_clear(List_Head *pHead)
 List_Node *list_prev_node(List_Head *pHead, List_Node *pNode)
 {
 	List_Node *pPrev = NULL, *pTemp;
-
 	if(pHead == NULL || pNode == NULL)
 		return NULL;
 	pTemp = pHead->pNext;

lib_ll.h

@@ -50,9 +50,6 @@ List_Node *list_search(List_Head *);
 /* return address of end of list */
 List_Node *list_tail(List_Head *);
 
-/* print list contents and details */
-void list_print(List_Head *);
-
 /* push new node on head of list */
 List_Node *list_ins_head(List_Head *);
 
@@ -76,6 +73,21 @@ int list_rm_node(List_Head *pHead, List_Node *);
 */
 int list_rm_before(List_Head *pHead, List_Node *);
 
+/* make a deep copy of list */
+int list_copy(List_Head *pDest, List_Head *pSrc);
+
+/* print out contents of list to stdout */
+void list_print(List_Head *pHead);
+
+/* get address of node at num - first node is 1 */
+List_Node *list_get_num(List_Head *pHead, int count);
+
+/* reverse current nodes - modify pointer to next in each */
+int list_node_swap(List_Node *pPrev, List_Node *pCurr);
+
+/* reverse contents of list */
+List_Head *list_reverse(List_Head *pHead);
+
 /* remove all nodes in list and free memory for each node */
 void list_clear(List_Head *);