1. 1 CSE 1342 Programming Concepts Lists

2. 2 Basic Terminology A list is a finite sequence of zero or more elements. –For example, (1,3,5,7) is a list of the odd integers from 1 to 7 inclusive. The length of the list is the number of elements in the list. The first element of the list is called the head. The remaining elements of the list are collectively called the tail. A sublist is a series of consecutive elements in a list not necessarily starting at the head.

3. 3 Basic Terminology A prefix is a sublist that starts at the head of a list. A suffix is a sublist that terminates at the end of a list. Each element in a list is associated with a position. –For example, (3, 5, 23, 100) is a list containing four elements with the 3 occupying position 1, the 5 occupying position 2, and so on. –The number of positions in a list equals the length of the list. –A particular value can appear at multiple positions in a list.

4. 4 Operations on Lists A list must support the following operations: –Insertion of new elements. –Deletion of existing elements. –Verification that an element is/isn’t in the list A data set upon which we can execute an insert, delete, and look-up is called a dictionary, no matter how the set is implemented or what it is used for. A list is a dictionary.

5. 5 Operations on Lists Other optional list operations: –Retrieval of a particular element in the list. –Calculate the length of the list. –Determine if the list is empty.

6. 6 The Linked-List Data Structure Each cell (element) in the linked-list will have the following general format: struct Cell { int element; //data goes here Cell *nextCell; //ptr to next cell in the list }; The data element may be simple or complex. The list may be ordered or unordered.

7. 7 The Linked-List Data Structure Graphically a linked-list may be represented as: 4789 * L In this example –L is a pointer to the head of a four element list. –Each double box represents a cell. –The values 4, 7, 8, and 9 are the data values. –An arrow is a pointer to the next element in the list. –* is the symbol for a NULL pointer (end-of-list indicator).

8. 8 Recursive Lookup on an Unordered List int lookup(int x, Cell * L) { if (L = = NULL) return 0; // item not found else if (x = = L->element) return 1; // item found else return lookup(x, L->nextCell); }

9. 9 Recursive Delete on an Unordered List //This function deletes the value x from the list. If the value x //is not present in the list the function does nothing. Memory //belonging to the deleted cell is not freed. void delete(int x, Cell ** pL) { if ((*pL) != NULL) if (x = = ((*pL)->element) (*pL) = (*pL)->nextCell; else delete(x, &((*pL)->nextCell); }

10. 10 Recursive Insert on an Unordered List //This function adds a new cell to the end of the list //if the value x is not already in the list. void insert(int x, Cell ** pL) { if ((*pL) = = NULL) { (*pL) = new Cell; (*pL)->element = x; (*pL)->nextCell = NULL; } else if (x != ((*pL)->element) insert(x, &((*pL)->nextCell); }

11. 11 Recursive Lookup on an Sorted List int lookup(int x, Cell * L) { if (L = = NULL) return 0; // item not found else if (x > L->element) return lookup(x, L->nextCell); else if (x = = L->element) return 1; // item found else // x element, x cannot be in list return 0; // item not found }

12. 12 Analysis of List Algorithms All insert, delete and lookup operations on a list are O(n). The exception is an insert on an unsorted list that allows duplicate entries. In this case the running time is O(1). –Since the algorithm does not search for duplicate entries, all new entries are inserted in the front of the list (there is no looping involved).

13. 13 Doubly Linked-List Data Structure Graphically a doubly linked-list is represented as: 4 Head Doubly linked-lists … –Facilitate movement both forwards and backwards in the list. –Make deletion of a cell easier when the address of the cell to be deleted is already known. 56 ** Tail (optional)

14. 14 Doubly Linked-List Data Structure Each cell (element) in the doubly linked-list will have the following general format: struct Cell { int element; //data goes here Cell *nextCell; //ptr to next cell in the list Cell *previousCell; //ptr to previous cell }; The data element may be simple or complex. The list may be ordered or unordered.

15. 15 Delete on a Doubly Linked-List //The calling function supplies the address of the list and //the address of the node to be deleted. void delete(Cell * p, Cell ** pL) { //p points to cell to delete if (p->next != NULL) p->nextCell->previousCell = p->previousCell; if (p->previousCell = = NULL) //p points to first cell (*pL) = p->nextCell; else p->previousCell->nextCell = p->nextCell; }

16. 16 Lists Implemented as Arrays A list may also be implemented as an array. –Advantages to array implementation: Binary search may be used for look-ups. –Linked-lists are limited to sequential searches. Eliminates the need for pointers (except for the array name) and pointer notation. –Disadvantages to array implementation: List size is limited to array size. –Maximum possible list size must be known at compile time. –Potential for wasted memory. Insertion and deletion of list elements may require other list elements to be repositioned within the array.

17. 17 Stacks A stack is an abstract data type based on the list model. All stack operations are performed at one end of the list, known as the top. A stack is a last-in-first-out (LIFO) ADT. A stack may be implemented as an array or a linked-list.

18. 18 Stack Operations Assuming S is a stack of type ETYPE and x is an element of type ETYPE, the following is a set of operations common the the stack ADT.

19. 19 Array Implementation of Stacks

20. 20 Array Implementation of Stacks

21. 21 Linked-List Implementation of Stacks

22. 22 Linked-List Implementation of Stacks

23. 23 Queues A queue is an abstract data type based on the list model. All insertions into the queue are performed at the rear of the queue. All deletions from the queue are performed at the front of the queue. A queue is a first-in-first-out (FIFO) ADT. A queue may be implemented as an array or a linked-list.

24. 24 Queue Operations Assuming Q is a queue of type ETYPE and x is an element of type ETYPE, the following is a set of operations common the the stack ADT. –clear(Q) - Make the queue Q empty. –dequeue(Q, x) - If Q is empty return FALSE; else set x the the value at the front of Q, delete the front element of Q, and return TRUE. –enqueue(Q, x) - If Q is full return FALSE; else add x to the end of Q, and return TRUE. –isEmpty(Q) - Return TRUE is Q is empty; else return FALSE. –isFull(Q) - Return TRUE is Q is full; else return FALSE.

25. 25 Linked-List Implementation of a Queue