Dynamic Data Structures (II)

Size: px

Start display at page:

Download "Dynamic Data Structures (II)"

Oliver Berry
6 years ago
Views:

1 Lecture 23 Dynamic Data Structures (II) CptS 121 Summer 2016 Armen Abnousi

2 Data Structure Data structures are different ways of organizing data in computer We design new data structures to make the programs more efficient and also to make programming easier Array is a data structure Helpful to keep a collection of values of the same type It is easy to send them all together to one function Instead of using different names we can access different values only by changing the index Another data structure is linked list

3 Linked List A Linked List is a chain of nodes Each node consists of a data element and a pointer to the next node Each element can be a basic data value, an array or a combination of different values, a struct, etc. While we can have a fixed size linked list, the power of linked lists is in the ability to add/remove nodes dynamically. Data element Link pointer

4 Why Linked Lists? Say we have a sorted list, and we want to add a new element to the list. (a list of students; a new student registers) If we were to use arrays: we needed to find the index appropriate for the new element (i). In the best case, copy the elements in indices i to n, into indices i+1 to n+1 Change the value of element in index i, to the new element. n-i copies (if every element has only one value) Same problem when removing an element Insert 7 in the sorted array 0 i n i i+1 n n

5 Why Linked Lists? Say we have a sorted list, and we want to add a new element to the list. (a list of students; a new student registers) If we use linked lists: We need to create a node for the new element Find the appropriate place for the new node. (i) Set the pointer from the previous node (i-1) to point to the new node. Set the pointer for the new node to point to the node previously in its place No more copying element is involved, only changing two pointers. Insert 9 in the sorted linked list

6 Linked List We need to be able to identify where our list starts and where it ends We will set a pointer to the first node and call it. This pointer variable itself is not dynamically allocated, but the nodes that it refers to will be allocated dynamically We will set the pointer for the last element to NULL, so that we know that s the end of the list. (node*) Data element Link pointer NULL

7 Functions on Linked Lists We can implement multiple functions to work with a linked list: insert(element, ) adds one element to the beginning of the list isinlist(element, ) Traverses over the linked list to see if it contains the element removeelem(element, ) Finds the element in the list and removes its node insertinloc(element, loc, ) inserts the node containing element in the specified location of the list (loc-th node) removenodeloc(loc, ) removes the loc-th node from the list destroylist() removes all nodes from the list printlist() prints all elements of the list

8 Node struct Every node has a component of type node*. typedef struct int element; node_t* next; /* compiler error */ node_t;

9 Node struct Every node has a component of type node*. typedef struct node_t; int element; node_t* next; /* compiler error */ At the time of declaring node_t* component, node_t itself is not completed yet and therefore compiler does know what it is! Instead we can assign a tag to our struct (any name!) and use that tag to let the compiler know what the node_t* is: typedef struct node_t_tag int element; struct node_t_tag* next; node_t; This can be any other data type

10 Linked List Now let s write our main function, where we initialize our. In the beginning there is no node in the list, so the is NULL. By adding new elements we will allocate memory gradually. int main() node_t* = NULL; return 0; At the beginning there is no node in the list.

11 Insert Insert a node in the list: We can add the node to the beginning of the list Make the pointer in the new node to point to the first node in the original list Make the pointer to point to the new node

12 insert Let s update the main to include a call to the function for insert: int main() node_t* = NULL; = insert( 5, ); return 0; Note that we entered element 5 which is an int. Instead we can have any other data type, just by changing the component type for element in the struct Inserts a node containing element 5 in the list and updates the.

13 insert Now we will implement the function insert We want to return the updated node_t* insert(int entry, node_t* ) node_t* node; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) return ; node->num = entry; node->next = ; = node; Update the to point to the new node A pointer to node, so that we can allocate dynamic memory for a new node Update the element in new node to be the value we want to insert The new node will point to the first node in the original list. If the list was empty, the pointer will be NULL.

14 Traversing the list - print Print function should go over the list, from node to node, and print the elements stored in it. The traversal starts from the node pointed by and continues until it reaches the node where the pointer to next is NULL NULL Declare a new pointer (node_t*) to do the traversal. node_t* current = ; NULL current Print 9 current = current -> next;

15 Traversing the list - print Print function should go over the list, from node to node, and print the elements stored in it. The traversal starts from the node pointed by and continues until it reaches the node where the pointer to next is NULL NULL Declare a new pointer (node_t*) to do the traversal. node_t* current = ; NULL current Print 6 current = current -> next;

16 Traversing the list - print Root itself is a pointer, Now current is referring to the same node that is pointing to. Print function should go over the list, from node to node, and print the elements stored in it. The traversal starts from the node pointed by and continues until it reaches the node where the pointer to next is NULL. void printlist(int entry, node_t* ) node_t* current; for (current = ; current!= NULL; current = current->next) printf("%d\n", current->num); Because we do not want to lose the, we keep a new pointer to work with, while Keeping the unchanged

17 isinlist This function checks if a given element is stored in any of the nodes in the list and returns a true/false integer. Similar to print function as it traverses the list, but can stop the traversal when it finds the element: use a flag variable done int isinlist(int query, node_t* ) node_t* current; int inlist = 0, done = 0; for (current = ;!done && current!= NULL; current = current->next) if (current->num == query) return inlist; inlist = 1; done = 1; Done is the flag variable to stop the loop when it finds the element, inlist is the return value In addition to checking for the NULL pointer, we check for the done to stop the loop prematurely if we find the query early in list (Note that done and inlist are used similarly in the function, we could replace one by the other)

18 removeelem Given an input element, finds the element in the list and deletes the first node that contains the element from the list: (if there are multiple such nodes only the first one will be deleted) Remove 7

19 removeelem Given an input element, finds the element in the list and deletes the node containing the element from the list: Find the current node (containing the element) Change the pointer from the previous node to point to the next node. Free the current node Remove

20 removeelem node_t* removeelem(int elem, node_t* ) node_t* removed = ; node_t* prev = NULL; int done = 0; for (removed = ;!done && removed!= NULL;) if (removed->num == elem) done = 1; else prev = removed; removed = removed->next; if (done) return ; if (prev!= NULL) prev->next = removed->next; else = removed->next; free(removed); If the elem is found, this will connect prev to the next pointed to by the node that needs to be deleted. If prev is NULL then the node to be Removed is the first node, so we will change the Locates the element in the list: removed refers to the node containing the element and prev, to the node before that. If removed is the first node, prev will be NULL.

21 removeelem node_t* removeelem(int elem, node_t* ) node_t* removed = ; node_t* prev = NULL; int done = 0; for (removed = ;!done && removed!= NULL;) if (removed->num == elem) done = 1; else prev = removed; removed = removed->next; if (done) return ; if (prev!= NULL) prev->next = removed->next; else = removed->next; free(removed); Updating the removed in the if statement inside the loop rather than as the third statement in the for loop, allows us to exit the loop without changing the values for removed or prev. If we had it like: for (remvd=;!done && remvd!=null; remvd=remvd->next) Then in the last iteration where we set done=1, we would still change the removed and then exit the loop, losing the correct node to remove.

22 Pointer to pointer variable In insert and remove functions we returned a node_t* variable (the ). We can use an output parameter for this variable and send a integer status variable as a returned value. For output parameters we have always used pointers. Now, since our variable itself is a pointer, we will need to send/receive a pointer to a pointer.

23 Insert with output node_t* parameter int insert(int entry, node_t** ) node_t* node; int status = 0; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) node->num = entry; node->next = *; * = node; status = 1; return status;

24 destroylist Starting from the first node, traverses the list, and as it moves forward, frees the memory for the current node: void destroylist(node_t** ) node_t* current = *; node_t* nextnode; while (current!= NULL) nextnode = current->next; free(current); current = nextnode; * = NULL;

25 Linked List in Memory We declared the as a local variable of type node_t* in main. => it s stored in the stack. main stack NULL heap int main() node_t* = NULL; = insert(5, ); Green font means the program has executed those instructions

26 stack Linked List in Memory Every time we insert a node, we request a malloc: Green font means the program has executed those instructions int main() node_t* = NULL; main insert entry (5) node NULL NULL heap = insert(5, ); node_t* insert(int entry, node_t* ) node_t* node; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) return ; node->num = entry; node->next = ; = node;

27 stack Linked List in Memory Every time we insert a node, we request a malloc: Green font means the program has executed those instructions int main() node_t* = NULL; main insert entry (5) node NULL NULL heap num? next? = insert(5, ); node_t* insert(int entry, node_t* ) node_t* node; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) return ; node->num = entry; node->next = ; = node;

28 stack Linked List in Memory Every time we insert a node, we request a malloc: Green font means the program has executed those instructions main insert entry (5) node NULL NULL heap 5 NULL int main() node_t* = NULL; = insert(5, ); node_t* insert(int entry, node_t* ) node_t* node; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) return ; node->num = entry; node->next = ; = node;

29 stack Linked List in Memory Every time we insert a node, we request a malloc: Green font means the program has executed those instructions main insert entry (5) node NULL heap 5 NULL int main() node_t* = NULL; = insert(5, ); node_t* insert(int entry, node_t* ) node_t* node; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) return ; node->num = entry; node->next = ; = node;

30 stack Linked List in Memory Every time we insert a node, we request a malloc: Green font means the program has executed those instructions main Data area for the function Insert is deleted (popped) from the stack as soon as it returns from the function heap 5 NULL int main() node_t* = NULL; = insert(5, ); node_t* insert(int entry, node_t* ) node_t* node; node = (node_t*)malloc(sizeof(node_t)); if (node!= NULL) return ; node->num = entry; node->next = ; = node;

31 stack Linked List in Memory Every time we insert a node, we request a malloc: Green font means the program has executed those instructions heap int main() node_t* = NULL; = insert(5, ); = insert(7, ); main Data area for the function Insert is deleted (popped) from the stack as soon as it returns from the function 7 5 NULL

32 Stack Data Structure Using Linked Lists We have implemented stacks using arrays before Stack can be implemented using linked lists as well If we only allow to insert to or remove from the head of the list (first node), then we have a stack. push(3); push(+); push(5); NULL pop(); + 3 NULL

33 Can you re-write the functions for isinlist, removeelem, destroylist with a recursive viewpoint?

34 Detecting Memory Leaks (optional) for (i = 0; i < 10; i++) ip = malloc(sizeof(int)); This will result in memory leak! In Every iteration one block of memory is allocated and is accessible using the ip pointer. In the next iteration, a new block is allocated and ip is modified, leaving the previous block without a pointer. The blocks allocated in iterations 0 to 8 are not accessible anymore, neither are freed! => memory leak

35 Detecting Memory Leaks (optional) for (i = 0; i < 10; i++) ip = malloc(sizeof(int)); stack heap ip i = 0

36 Detecting Memory Leaks (optional) for (i = 0; i < 10; i++) ip = malloc(sizeof(int)); stack heap ip i = 1 There is no pointer to this block anymore It is unattained but not fred! Memory leak

37 Detecting Memory Leaks (optional) for (i = 0; i < 10; i++) ip = malloc(sizeof(int)); stack heap ip i = 2 There is no pointer to this block anymore It is unattained but not fred! Memory leak

38 Detecting Memory Leaks (optional) Forgetting to free allocated dynamic memory, can result in your computer running out of memory when running your program. The program might stop with runtime error, or your computer might slow down. Specially when memory allocation happens in a loop, you must carefully design the algorithm to make sure every unused block of memory is freed. Make sure every block of memory that is allocated, has at least one pointer to it. (Otherwise, you have some data in the memory but there is no way of accessing it).

39 Detecting Memory Leaks (optional) You can detect memory leaks in Visual Studio using the CRT library: Include/define these in order: #define _CRTDBG_MAP_ALLOC #include <stdlib.h> #include <crtdbg.h> Before every exit point of your program enter: _CrtDumpMemoryLeaks(); *return statements in the main and any other exit() command are exit points of your program.

40 Detecting Memory Leaks (optional) Visual Studio #define _CRTDBG_MAP_ALLOC #include <stdlib.h> #include <crtdbg.h> #include <stdio.h> int main() int* ap; ap = malloc(sizeof(int)); _CrtDumpMemoryLeaks(); return 0; Allocated but not freed

Detecting Memory Leaks (optional) Linux systems There are multiple tools that can be used Valgrind is a debugging tool for memory management problems

41 Detecting Memory Leaks (optional) Linux systems There are multiple tools that can be used Valgrind is a debugging tool for memory management problems in linux systems One of the facilities valgrind provides is to check for memory leaks Valgrind is probably the best known tool for finding memory leaks

42 Garbage Collection (optional) Some libraries offer garbage collection Garbage collection is a form of automatic memory management Garbage collector looks for allocated memory blocks that don t have any pointer to them (are not used) and deallocates them. This operation happens automatically.

43 Smart Pointers in C++ (optional) A smarter implementation of pointers is called smart pointer. Smart pointers do the deallocation automatically. Smart pointers are available in C++ (and not in C). For a start point, look up smart pointer and/or shared_ptr.

44 References J.R. Hanly & E.B. Koffman, Problem Solving and Program Design in C (8thed.), Pearson, 2016

The combination of pointers, structs, and dynamic memory allocation allow for creation of data structures

Data Structures in C C Programming and Software Tools N.C. State Department of Computer Science Data Structures in C The combination of pointers, structs, and dynamic memory allocation allow for creation