Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
CSE 1342 Programming Concepts Lists 1 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. 2 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. 3 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. 4 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. 5 The Linked-List Data Structure • Each cell (element) in the linked-list will have the following general format: struct Cell { int element; Cell *nextCell; }; //data goes here //ptr to next cell in the list • The data element may be simple or complex. • The list may be ordered or unordered. 6 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). 7 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); } 8 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); } 9 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); } 10 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 < L->element, x cannot be in list return 0; // item not found } 11 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). 12 Doubly Linked-List Data Structure Graphically a doubly linked-list is represented as: * 4 5 6 * Tail Head (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. 13 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. 14 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; } 15 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. 16 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. 17 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. 18 Array Implementation of Stacks 19 Array Implementation of Stacks 20 Linked-List Implementation of Stacks 21 Linked-List Implementation of Stacks 22 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. 23 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. 24 Linked-List Implementation of a Queue 25