Download Lists

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