1. Lists List: finite sequence of data elements
all elements have the same data type
The operations depend on the type of the list and not on the data type
List: the most general type
Ordered: element is ascending order
Stacks, Queues: not all operations are allowed
E.G.M. Petrakis
lists

2. Insertion after current
list or
head
info
next
list
new element
Insertion after current
position
current
rear or
tail
E.G.M. Petrakis
lists

3. Insertion at current position
list or
head
list
new element
Insertion at current position
current
rear or
tail
E.G.M. Petrakis
lists

4. Deletion after current
list or
head
deleted
element
Deletion after current
position
current
rear or
tail
E.G.M. Petrakis
lists

5. current Deletion at current position deleted element list or rear or
head
deleted
element
Deletion at current
position
current
rear or
tail
E.G.M. Petrakis
lists

6. Terminology empty: contains no elements
length: number of elements in list
head, or list: pointer to the beginning of the list
tail: pointer to the last element
current: pointer to current element
ordered: elements in ascending or descending order
E.G.M. Petrakis
lists

7. Operations setFirst: set “current” to “head”
setPos(i): sets current to the i-th element
currValue: returns value of “current” element
next/prev: “current” points to next/previous element
clear: delete all elements
insert: inserts an element at/after current position
append: inserts an element at “tail”
remove: delete the element at/after “current” position
find(key): set current to the first occurrence of “key”
isInList: true/false if current position is in list
isEmpty: true/false if list is empty
E.G.M. Petrakis
lists

8. ADT List
template <class ELEM> class list { // list class ADT in C++
public:
list(const int = LIST_SIZE); // constructor
~list( ); // destructor
void clear ( ); // remove all elements
void insert(const ELEM &); // inset at current
void append(const ELEM &); // insert at tail
ELEM remove ( ); // remove current
void setFirst ( ); // set current to HEAD
void prev ( ) ; // set current to previous
void next ( ); // set current to next
int length ( ) const; // return size of list
void setPos(const int); // set current to new pos
void setValue(const ELEM &) // set current’s value
bool isEmpty( ) const; // true/false on empty
bool isInList( ) const; // true/false if current is in list
bool find(const ELEM &); // find value of current };
E.G.M. Petrakis
lists

9. Iteration Iterate through the whole list : MyList
for (MyList.first( ); MyList.isInList( ); MyList.next( ))
DoSomething(MyList.currValue( ));
If MyList: ( ) and current points to 32 then MyList.insert(90) changes the list to be ( )
E.G.M. Petrakis
lists

10. List Implementations Array-based: very fast
the elements are stored in array
static: actual number of elements less than size allocated
Dynamic Memory: slower, more efficient
allocates memory for new elements
dynamic: no restriction on number of elements (except memory size)
E.G.M. Petrakis
lists

11. Array Implementation (1)
Elements in continuous array positions
Head of list at pos 0
Insertion and Deletion cause shifting of elements
E.G.M. Petrakis
lists

12. template <class ELEM> class list { //array based list class
private:
int msize // maximum size of list
int numinlist //actual number of ELEMs
int curr; // position of “current”
ELEM* listarray; //array holding ELEMs
public:
list (const int=LIST_SIZE); // constructor
~list( ); // destructor
void clear( ); // remove all ELEMs from list
void insert(const ELEM &); // insert ELEM at current position
void append(const ELEM &); // insert ELEM at tail of list
ELEM remove( ); // remove and return current ELEM
void setFirst( ); // set current to first position
void prev( ); // move current to previous position
void next( ); // move current to next position
int length( ) const; // return current length of list
void setPos(const int); // set current to specified position
void setValue(const ELEM &); // set current ELEM's value
ELEM currValue( ) const; // return current ELEM's value
bool isEmpty( ) const; // return TRUE if list is empty
bool isInList( ) const; // TRUE if current is within list
bool find(const ELEM &); // find value (from current position) };
E.G.M. Petrakis
lists

13. template <class ELEM>
List<ELEM>::List(int sz) // constructor: initialize
{ msize = sz; numinlist = 0; curr = 0; listarray = new ELEM[sz]; }
List<ELEM>::~List( ) // destructor: return array space
{ delete [ ] listarray; }
void List<ELEM>::clear( ) // remove all Elems from list
{ numinlist = 0; curr = 0; } // reinitialize values
void List<ELEM>::insert(const Elem item) { // insert Elem at current position
// the array must not be full and “curr” must be a legal position
assert((numinlist < msize) && (curr >= 0) && (curr <= numinlist));
for(int i = numinlist; i > curr; i--) // shift element up to make room
listarray[i] = listarray[i - 1];
listarray[curr] = item;
numinlist++; // increment current list size }
E.G.M. Petrakis
lists

14. template <class ELEM>
void List<ELEM>::append(const Elem item) { // insert Elem at tail of list
assert(numinlist < msize); // list must not be full
listarray[numinlist++] = item; // increment list size }
ELEM List<ELEM>::remove( ) { // remove and return current Elem
assert( !isEmpty( ) && isInList( ) ); // must be an Elem to remove Elem
temp = listarray[curr]; // store removed Elem
for (int i=curr; i < numlist-1; i++) // shift elements down
listarray[i] = listarray[i+1];
numinlist--; // decrement current list size
return temp;
void List<ELEM>::setFirst( ) // set curr to first position
{ curr = 0; }
void List<ELEM>::prev( ) // move curr to previous position
{ curr--; }
E.G.M. Petrakis
lists

15. template <class ELEM>
void List<ELEM>::next( ) // move curr to next position
{ curr++; }
int List::length( ) const // return current length of list
{ return numinlist; }
void List<ELEM>::setPos(int pos) // set curr to specified position
{curr = pos; }
void List<ELEM>::setValue(const Elem val) { // set current Elem's value
assert(isInList( )); // curr must be at valid position
listarray[curr] = val; }
Elem List<ELEM>::currValue( ) const { // return current Elem's value
assert(isInList( )); // must be at a valid position
return listarray[curr];
E.G.M. Petrakis
lists

16. } template <class ELEM>
bool List<ELEM>::isEmpty( ) const // return TRUE if list is empty
{ return numinlist == 0; }
bool List<ELEM>::isInList( ) const // TRUE if curr is within list
{ return (curr >= 0) && (curr < numinlist); }
bool List<ELEM>::find(int val) { // find value (starting at curr)
while (isInList( )) // stop if reach end
if (key(currValue( )) == val)
return TRUE; // found it
else next( );
return FALSE; // not found }
E.G.M. Petrakis
lists

17. Array Implementation (2)1 11 5 26
list 10 12 8 9 13
nodes
NULL
E.G.M. Petrakis
lists

18. 31 3 14 37 6 5 12
List 1 17 26
List 2 19 32
List 3 1 18 13 11 4 15
List 4
E.G.M. Petrakis
lists

19. List 4 List 2 List 3 List 1 E.G.M. Petrakis lists 1 26 2 11 10 3 5 162 11 10 3 5 16 4 25 17 6 13 7 8 19 9 14 22 12 31 15 37 24 18 32 20 21 23
List 4
List 2
List 3
List 1
E.G.M. Petrakis
lists

20. template <class ELEM> class list { // array based list class
private:
int msize // maximum size of list
int numinlist // actual number of ELEMs
int curr; // position of “current”
int avail; // next available position
ELEM* listarray; // array holding ELEMs
int* listarray_next; // array holding pointers to next ELEMs
int get_node( ); // get position of available node
void free_node( ); // return node in array
void insert(int, const ELEM&); // insert after the node pointed by p
void delete(int, ELEM*); // delete after the node pointed by p
public:
list (const int=LIST_SIZE); // constructor
~list( ); // destructor
void clear( ); // remove all ELEMs from list
void insert(const ELEM&); // insert ELEM at current position
void append(const ELEM&); // insert ELEM at tail of list
ELEM remove( ); // remove and return current ELEM
void setFirst( ); // set curr to first position;
void prev( ); // move curr to previous position;
void next( ); // move curr to next position;
int length( ) const; // return current length of list };
E.G.M. Petrakis
lists

21. template <class ELEM>
List<ELEM>::list(int sz) { // constructor: initialize
msize = sz;
numinlist = 0;
curr = 0;
listarray = new Elem[sz];
listarray_next = new int[sz];
avail = 0; // the first available element
for (i=0; i < msize; i++)
listarray_next[i] = i+1; // each elem points to its successor
listarray_next[msize-1] = nothing; // the last elem has no next }
List<ELEM>::~list( ) // destructor: return array space {
delete [ ] listarray;
delete [ ] listarray_next;
E.G.M. Petrakis
lists

22. template <class ELEM>
int list<ELEM>::get_node( ) { //get next available node
if (avail == nothing) // from stack
error(‘list overflow’)
else {
int pos = avail;
avail = listarray_next[avail];
return pos; }
template <class ELEM> // make node available
void list<ELEM>::free_node (int p) {
listarray_next[p] = avail; // push node back to stack
avail =p;
E.G.M. Petrakis
lists

23. template <class ELEM> // insert after node pointed to by “p”
void list<ELEM> ::insert(int p, const ELEM& x) {
if (p < 0 || p >= msize)
error (‘void insertion’)
else {
int q = get_node( );
listarray[q] = x;
listarray_next[q] = listarray_next[p];
listarray_next[p] = q; }
template <class ELEM>
void list<ELEM> ::delete(int p; ELEM* x) {
if ( p > 0 || p >= msize) // deletes elem after elem
error (‘void deletion’); // pointed to by “p”
int q = listarray_next[p];
*x = listarray[q];
listarray_next[p] = listarray_next[q];
free_node(q);
E.G.M. Petrakis
lists

24. Dynamic Memory The node class
Allocates memory for new elements as needed
Each node is a distinct object
The node class
template <class ELEM> class link { // a linked-list node
public:
ELEM element // node value
link *next; // pointer to next node
link(const ELEM & val, link *nextval = NULL);
{element = val; next = nextval;}
link(link *nextval = NULL) {next = nextval;}
~link( ) { } }
E.G.M. Petrakis
lists

25. template <class Elem> class List { // Linked list class private:
Link<Elem>* head; // pointer to list header
Link<Elem>* tail; // pointer to last Elem in list
Link<Elem>* curr; // position of "current" Elem
public:
List( ); // constructor
~List( ); // destructor
void clear( ); // remove all Elems from list
void insert(const Elem); // insert Elem after current position
void append(const Elem); // insert Elem at tail of list
Elem remove( ); // remove and return after current Elem
void setFirst( ); // set curr to first position
void prev( ); // move curr to previous position
void next( ); // move curr to next position
int length( ) const; // return current length of list
void setPos(int); // set curr to specified position
void setValue(const Elem); // set current Elem's value
Elem currValue( ) const; // return current Elem's value
bool isEmpty( ) const; // return TRUE if list is empty
bool isInList( ) const; // TRUE if curr is within list
bool find(Elem); // find value (from current position) };
E.G.M. Petrakis
lists

26. template <class Elem> List<Elem>::List( ) // constructor
{ head = new Link<Elem>; tail = head; curr = head; } // initialize
List<Elem>::~List( ) { // destructor
while(head != NULL) { // return link nodes to free store
curr = head;
head = headnext;
delete curr; }
void List<Elem>::clear( ) { // remove all Elems from list
while (headnext != NULL) { // return link nodes to free store
curr = headnext; // keeps header node !!
headnext = currnext; // otherwise, similar to ~List( )
tail = head; // reinitialize
E.G.M. Petrakis
lists

27. template <class Elem>
void List<Elem>::insert(const Elem item) // insert Elem after current
{ assert(curr != NULL); // must be pointing to list Elem
currnext = new Link<Elem>(item, currnext);
if (tail == curr) // appended
new Elem tail = currnext; }
void List<Elem>::append(const Elem item) // insert Elem at tail of list
{ tail = tailnext = new Link<Elem>(item, NULL); }
Elem List<Elem>::remove( ) { // remove elem after current
assert(isInList( )); // must be valid position in list
Elem temp = currnextelement; // remember value
Link<Elem>* ltemp = currnext; // remember link node
currnext = ltempnext; // remove from list
if (tail == ltemp) tail = curr; // removed last Elem: set tail
delete ltemp; // send link to free store
return temp; // return value removed
E.G.M. Petrakis
lists

28. template <class Elem>
void List<Elem>::setFirst( ) // set curr to first position
{ curr = head; }
void List <Elem>::next( ) // move curr to next position
{ if (curr != NULL) curr = currnext; }
void List <Elem>::prev( ) { // move curr to previous pos
Link<Elem>* temp = head;
if ((curr == NULL) || (curr == head)) // no previous Elem
{ curr = NULL; return; } // so just return
while ((temp!=NULL) && (tempnext != curr)) temp=tempnext;
curr = temp; }
int List <Elem>::length( ) const { // return current length of list
int cnt = 0;
for (Link<Elem>* temp = headnext; temp != NULL; temp = tempnext) cnt++; // count Elems and return cnt;
E.G.M. Petrakis
lists

29. template <class Elem>
bool List <Elem>::find(Elem val) { // find value (starting at curr)
while (isInList( ))
if (key(currnextelement) == val)
return TRUE;
else
curr = currnext;
return FALSE; // not found }
void List<Elem>::setPos(int pos) { // set curr to position
curr = head;
for (int i = 0; (curr != NULL) && (i < pos) i++) curr = currnext;
void List<Elem>::setValue(const Elem val) { // set current Elem's value
assert(isInList());
currnextelement = val;
E.G.M. Petrakis
lists

30. template <class Elem>
Elem List<Elem>::currValue const // return value of current Elem
{ assert(isInList( )); return currnextelement; }
bool List<Elem>::isEmpty( ) const // return TRUE if list is empty
{ return headnext == NULL; }
bool List<Elem>::isInList( ) const // TRUE if curr is within list
{ return (curr != NULL) && (currnext != NULL); }
E.G.M. Petrakis
lists

31. Comparison Array-Based Lists: Linked Lists:
insertion and deletion are (n)
prev and direct access are (1)
fixed space allocated in advance
space reorganization if the array is full
faster in most cases
Linked Lists:
insertion and deletion are (1)
prev and direct access are (n)
space grows with number of elements
every element requires overhead
slower
E.G.M. Petrakis
lists

32. Doubly Linked List
Allows for direct access to both next and previous elements of the current pointer
insert (delete) operations update both “next” and “prev” pointers
easy implementation
curr next = new (item, currnext, curr);
if (currnext != NULL)
currnextprev = currnext
E.G.M. Petrakis
lists

33. Insertion in Doubly Linked List
current
E.G.M. Petrakis
lists

34. Deletion in Doubly Linked List
current
current
E.G.M. Petrakis
lists

35. Circular Linked Lists
The next pointer of the last element points to the first element
E.G.M. Petrakis
lists