CSE 1342 Programming Concepts Lists

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.

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.

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.

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.

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.

The Linked-List Data Structure Graphically a linked-list may be represented as: 4 7 8 9 * 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).

Iterative Lookup on an Unordered List boolean lookup(int x, Cell * L) { while (L != nullptr) { if (x = = L->element) return true; // item found L = L->nextCell; } return false;

Recursive Lookup on an Unordered List boolean lookup(int x, Cell * L) { if (L = = nullptr) return false; // item not found else if (x = = L->element) return true; // item found else return lookup(x, L->nextCell); }

Iterative Insert on an Ordered List //This function adds a new cell at the appropriate location in //an ordered list. void insert(int x, Cell ** pL) { Cell* newCell = new Cell; newCell->element = x; while ((*pL ! = nullptr) && (x > (*pL)->element)) { pL = &((*pL)->nextCell); } newCell->nextCell = *pL; *pL = newCell;

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 = = nullptr) { *pL = new Cell; (*pL)->element = x; (*pL)->nextCell = NULL; } else if (x != ((*pL)->element) insert(x, &((*pL)->nextCell);

Iterative Lookup on an Sorted List boolean lookup(int x, Cell * L) { while (L ! = nullptr) { if (x = = L->element) return true; // item found if (x > L->element) L = L->nextCell); else // x < L->element, x cannot be in list return false; // item not found }//end while return false; }

Recursive Lookup on an Sorted List boolean lookup(int x, Cell * L) { if (L = = nullptr) return false; // item not found else if (x > L->element) return lookup(x, L->nextCell); else if (x = = L->element) return true; // item found else // x < L->element, x cannot be in list return false; // item not found }

Iterative 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. void delete(int x, Cell ** pL) { while ((*pL) != nullptr) { if (x = = ((*pL)->element) { Cell ** tempPtr = pL; *pL = (*pL)->nextCell; delete *pL; return; } else pL = &((*pL)->nextCell); } //end while }//end delete

Iterative 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 freed. void delete(int x, Cell ** pL) { Cell** temp; while (*pL != nullptr) { if (x = = ((*pL)->element) { *temp = *pL; *pL = (*pL)->nextCell; delete *temp; return; } pL = &((*pL)->nextCell); }//end while }//end delete

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 != nullptr) if (x = = ((*pL)->element) *pL = (*pL)->nextCell; else delete(x, &((*pL)->nextCell); }

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).

Doubly Linked-List Data Structure Graphically a doubly linked-list is represented as: 4 5 6 * * Head Tail (optional) 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.

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.

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 != nullptr) p->nextCell->previousCell = p->previousCell; if (p->previousCell = = nullptr) //p points to first cell (*pL) = p->nextCell; else p->previousCell->nextCell = p->nextCell; }

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.

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.

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.

Array Implementation of Stacks

Array Implementation of Stacks

Linked-List Implementation of Stacks

Linked-List Implementation of Stacks

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.

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.

Linked-List Implementation of a Queue