![Data Structures
Example result
4
#include <stdio.h>
int main(int argc, char *argv[]) {
int y, *aP, *bP; // pointer vars use * in declaration
y = 3;
aP = &y;
*aP = 17;
printf("aP: %pn",aP);
printf("*aP = %dn",y); // prints out what?
printf("bP: %pn",bP);
*bP = 1; // what happens? (hint: DOOM)
return 0;
}
aP: 0xbffffa54
*aP = 17
bP: 0x8048441
Segmentation fault (core dumped)](https://image.slidesharecdn.com/03-lists-230417131148-248a17a0/85/03-Lists-ppt-4-320.jpg)
![Data Structures
Array List Insert Operation
Basic Idea: Insert new item and shift old items
to the right.
10
void Insert(List L, ElementType e, Position p) {
Position current;
if (p > L->count || L->count == MAX_SIZE) exit(1);
current = L->count;
while (current != p) {
L->a[current] = L->a[current-1];
current--;
}
L->a[current] = e;
L->count++;
}](https://image.slidesharecdn.com/03-lists-230417131148-248a17a0/85/03-Lists-ppt-10-320.jpg)
![Data Structures
Polynomial ADT
Store and manipulate single variable polynomials with non-
negative exponents
10x3 + 4x2 + 7 ( = 10x3 + 4 x2 + 0 x1 + 7 x0 )
Store coefficients Ci and exponents i
ADT operations
Addition: C[i] = A[i] + B[i];
Multiplication: C[i+j] = C[i+j] + A[i]*B[j];
25](https://image.slidesharecdn.com/03-lists-230417131148-248a17a0/85/03-Lists-ppt-25-320.jpg)
![Data Structures
Polynomial Implementation
Array Implementation: C[i] = Ci
E.g. C[3] = 10, C[2] = 4, C[1] = 0, C[0] = 7
Problem with Array implementation
High-order sparse polynomials require large sparse arrays
E.g. 10X3000 + 4 X2+ 7 Waste of space and time (Ci are mostly
0s)
Instead, use singly linked lists, sorted in decreasing order
of exponents
26](https://image.slidesharecdn.com/03-lists-230417131148-248a17a0/85/03-Lists-ppt-26-320.jpg)
![Data Structures
Bucket Sort: Sorting integers
Bucket sort: N integers in the range 0 to B-1
Array Count has B elements (“buckets”), initialized to 0
Given input integer i, Count[i]++
After reading all N numbers go through the B buckets and read
out the resulting sorted list
N operations to read and record the numbers plus B operations
to recover the sorted numbers
27](https://image.slidesharecdn.com/03-lists-230417131148-248a17a0/85/03-Lists-ppt-27-320.jpg)
03-Lists.ppt
- 1. Lists Data Structures and Algorithm Analysis in C, by Mark Allen Weiss, 2nd edition, 1997, Addison-Wesley, ISBN 0-201-49840-5 Danang University of Science and Technology Dang Thien Binh [email protected]
- 2. Data Structures Readings and References Reading Sections 3.1 - 3.2.8, Data Structures and Algorithm Analysis in C, Weiss Other References 2
- 3. Data Structures Review: Pointers and Memory Recall that memory is a one-dimensional array of bytes, each with an address Pointer variables contain an address 3 int y, *aP, *bP; // pointer vars use * in declaration y = 3; aP = &y; *aP = 17; printf("aP: %pn",aP); printf("*aP = %dn",y); // prints out what? printf("bP: %pn",bP); *bP = 1; // what happens? (hint: DOOM)
- 4. Data Structures Example result 4 #include <stdio.h> int main(int argc, char *argv[]) { int y, *aP, *bP; // pointer vars use * in declaration y = 3; aP = &y; *aP = 17; printf("aP: %pn",aP); printf("*aP = %dn",y); // prints out what? printf("bP: %pn",bP); *bP = 1; // what happens? (hint: DOOM) return 0; } aP: 0xbffffa54 *aP = 17 bP: 0x8048441 Segmentation fault (core dumped)
- 5. Data Structures Review: Memory Management Use “malloc” to allocate a specified number of bytes for new variables aP = (int *) malloc(sizeof(int)); Use the sizeof operator to compute the number of bytes needed for the data type malloc does not initialize the memory To deallocate memory, use “free” and pass a pointer to an object allocated with malloc free(aP); 5
- 6. Data Structures List ADT What is a List? Ordered sequence of elements A1, A2, …, AN Elements may be of arbitrary type, but all are the same type Common List operations are Insert, Find, Delete, IsEmpty, IsLast, FindPrevious, First, Kth, Last 6
- 7. Data Structures List Implementations Two types of implementation: Array-Based Pointer-Based 7
- 8. Data Structures List: Array Implementation Basic Idea: Pre-allocate a big array of size MAX_SIZE Keep track of current size using a variable count Shift elements when you have to insert or delete 8 AN … A4 A3 A2 A1 MAX_SIZE-1 count-1 … 3 2 1 0
- 9. Data Structures List: Array Implementation typedef struct _ListInfo ( ElementType *theArray; //= malloc(MAX_SIZE*sizeof(ElementType)) int count; // = 0 int maxsize; //=MAX_SIZE } typedef ListInfo *List; typedef int Position; //Empty list has allocated array and count = 0 Need to define: void Insert(List L, ElementType E, Position P) // Example: Insert E at position P = 2 9 AN … A4 A3 A2 A1 MAX_SIZE-1 count-1 … 3 2 1 0
- 10. Data Structures Array List Insert Operation Basic Idea: Insert new item and shift old items to the right. 10 void Insert(List L, ElementType e, Position p) { Position current; if (p > L->count || L->count == MAX_SIZE) exit(1); current = L->count; while (current != p) { L->a[current] = L->a[current-1]; current--; } L->a[current] = e; L->count++; }
- 11. Data Structures Array List Insert Running Time Running time for N elements? On average, must move half the elements to make room Worst case is insert at position 0. Must move all N items down one position before the insert This is O(N) running time. 11
- 12. Data Structures List: Pointer Implementation Basic Idea: Allocate little blocks of memory (nodes) as elements are add ed to the list Keep track of list by linking the nodes together Change links when you want to insert or delete 12 Value NULL pL node Value Next node Next
- 13. Data Structures List: A Pointer Implementation struct Node { ElementType Value; struct Node *next; }; typedef struct Node *List; typedef struct Node *Position; // Pointer to an empty list = NULL void Insert(List *pL, ElementType E, Position P) // Insert adds new node after the one pointed to by P // if P is NULL or list is empty (pL=NULL), insert at beginning of l ist 13
- 14. Data Structures Pointer-Based Linked List 14 Value NULL pL node Value Next node Next
- 15. Data Structures List: A Pointer Implementation // Insert adds new node after the one pointed to by P // if P is NULL or list is empty, insert at beginning of list void Insert(List *pL, ElementType E, Position P) Position newItem; newItem = (struct Node *)malloc(sizeof(struct Node)); FatalErrorMemory(newItem); newItem->Value = E; if (pL == NULL || P == NULL) { //insert at head of list newItem->next = pL; pL = newItem; } else { // insert newItem after the node pointed to by P newItem->next = P->next; P->next = newItem; } 15
- 16. Data Structures Pointer-based Insert Operation 16 Value NULL pL node Value Next node P Insert the value E after P Next Value E Next
- 17. Data Structures Using a Header Node If the List pointer points to first item, then any change in first item changes List itself need special checks if List pointer is NULL L->next is invalid (L is not a Node struct) Solution: Use “header node” at beginning of all lists (see te xt) List pointer always points to header node, which points t o first actual list item Simplifies the code, but you need to remember that ther e is an "empty" node at the start of the list 17
- 18. Data Structures Linked List with Header Node 18 Value Next pL first actual list node Value ignore Next header node NULL
- 19. Data Structures Pointer Implementation Issues Whenever you break a list, your code should fix the list up as soon as possible Draw pictures of the list to visualize what needs to be done Pay special attention to boundary conditions: Empty list Single item – same item is both first and last Two items – first, last, but no middle items Three or more items – first, last, and middle items 19
- 20. Data Structures Pointer List Insert Running Time Running time for N elements? Insert takes constant time (O(1)) Does not depend on input size Compare to array bases list which is O(N) 20
- 21. Data Structures Pointer-Based Linked List Delete 21 Value Next pL node Value Next node P To delete the node pointed to by P, need a pointer to the previous node NULL
- 22. Data Structures Doubly Linked Lists FindPrev (and hence Delete) is slow because we cannot go directly to previous node Solution: Keep a "previous" pointer at each nod e 22 head prev prev prev
- 23. Data Structures Double Link Pros and Cons Advantage Delete and FindPrev are fast like Insert is Disadvantages: More space used up (double the number of pointers at each node) More book-keeping for updating the two pointers at eac h node 23
- 24. Data Structures Circularly Linked Lists Set the pointer of the last node to first node instead of NUL L Useful when you want to iterate through whole list starting f rom any node No need to write special code to wrap around at the end Circular doubly linked lists speed up both the Delete and L ast operations 24
- 25. Data Structures Polynomial ADT Store and manipulate single variable polynomials with non- negative exponents 10x3 + 4x2 + 7 ( = 10x3 + 4 x2 + 0 x1 + 7 x0 ) Store coefficients Ci and exponents i ADT operations Addition: C[i] = A[i] + B[i]; Multiplication: C[i+j] = C[i+j] + A[i]*B[j]; 25
- 26. Data Structures Polynomial Implementation Array Implementation: C[i] = Ci E.g. C[3] = 10, C[2] = 4, C[1] = 0, C[0] = 7 Problem with Array implementation High-order sparse polynomials require large sparse arrays E.g. 10X3000 + 4 X2+ 7 Waste of space and time (Ci are mostly 0s) Instead, use singly linked lists, sorted in decreasing order of exponents 26
- 27. Data Structures Bucket Sort: Sorting integers Bucket sort: N integers in the range 0 to B-1 Array Count has B elements (“buckets”), initialized to 0 Given input integer i, Count[i]++ After reading all N numbers go through the B buckets and read out the resulting sorted list N operations to read and record the numbers plus B operations to recover the sorted numbers 27
- 28. Data Structures Radix Sort: Sorting integers Radix sort = multi-pass bucket sort of integers in the range 0 to BP-1 Bucket-sort from least significant to most significant "digit" (base B) Use linked list to store numbers that are in same bucket Requires P*(B+N) operations where P is the number of passes (the number of base B digits in the largest possible input number) 28