linked Lists, lists, and their implementations
Ken Nguyen Spring 2002
Introduction
A vector has two disadvantages:
It is not efficient when the number of elements to be stored varies widely during a program execution. It is expensive to add or remove items anywhere except at the end (possibly the beginning)
List: A list is a kind of sequence that supports
bidirectional iterators and allows constant time insert and erase operations anywhere within the sequence, with storage management handled automatically. Unlike vectors fast random access to list elements is not supported, but many algorithms only need sequential access anyway.
Introduction cont
Linked list: elements are stored in a chain, with each element containing a pointer to the next element, (and a pointer to the previous element), in the list. The last element contains a NULL pointer. Linked lists does not provide random access to elements. Linked list is usually implemented using nodebase. (array-base linked list are rare).
Basic ideas
template <class Object> Front of list struct Node {
a b
c
d
Object element Node * next;
Figure 17.1
}; Last node has the next pointer point to NULL.
Basic ideas cont . . .
Inserting a node into a list: Node *tmp = new Node; tmp->element = x; tmp->next = current->next; current->next = tmp;
a x
tmp
b
current
Fig. 17.2
Basic ideas cont
a x a
current
Fig. 17.3
Deleting a node:
Node * deleteNode = current->next; curent->next = current->next->next; delete deleteNode;
Header node
A header node holds no data but serves to satisfy the requirement that every node has a previous node. header
a b c
header
Fig. 17.4
Fig. 17.5 an empty list
Simple Linked list
A list
Node
Node
Node
Node
Simple linked list cont
A list
Node
Node
Node
Node
Circular linked list
Node
Node
Node
Node
Node
Doubly linked list
Node
Node
struct Node{
Node
Node
Node
Object element; Node *prev; Node *next; };
Doubly linked list cont
Node
Node
Node
Node
Node
Insertion on doubly linked list
newNode = new Node; newNode->element = x; newNode->prev = current; newNode->next = current->next; newNode->prev->next = newNode; newNode->next->prev = newNode; current = newNode;
a
3 2 1 4
b x
Fig. 17.20
Sorted linked list
To make a linked list a sorted linked list, what has to be changed is the insert function.
Sample Implementations
list.h list.cpp LinkedList.h LinkedList.cpp
STL List Class
#include <list> list<T> v; list<T> v(aList); v = aList; v.swap(aList); v.remove(value); v.remove_if(predicate); list<T>::iterator itr; v.begin(); v.end(); v.rbegin(); v.rend() v.merge(aList); v.sort(); List header Default constructor O(1) Copy constructor O(n) Assignment O(n) Swap values with another list O(1) Remove all occurrences of value O(n) Remove all values that match the condition O(n) Declare a new iterator O(1) Starting iterator O(1) Ending iterator O(1) Starting backward moving iterator O(1) Ending backward moving itarator Merge O(1) with another ordered list O(n) Place elements in accending order O(nlogn)
STL List Examples
#include <list> list<int> list_one; list_one.push_front(5); list_one.push_back(10); int a = list_one.front(); ... list_one.remove(4); list_one.remove_if(even); //assume even is a functor list<int>::iterator start = list_one.begin(); list<int>::iteartor stop = list_one.end(); list_one.erase(start,stop);
STL List Examples cont . . .
list<int>::reverse_iterator current = list_one.rbegin(); while (current != list_one.rend()) cout << *current++ << ; list_one.sort(); list_one.sort(intCompare); //assume intCompare is a functor int num = 0; count(list_one.begin(), list_one.end(), 5, num); // using generic count function on list copy(list_one.begin(), list_one.end(), list_two.begin()); //copy list_one into list_two starting at the first element. //list_one = {1, 2, 3}, list_two = {6,7,8,9} => list_two = {1, 2, 3, 9} list<int>::iterator five = find(list_one.begin(), list_one.end(), 5);
Sequences and containers
Class bitset deque list queue stack Vector Header <bitset> <deque> <list> <queue> <stack> <vector>
STL Sequence Container operations
expression X(n, t) X a(n, t); X(i, j) X a(i, j); return type assertion/note pre/post-condition post: size() == n. constructs a sequence with n copies of t. post: size() == distance between i and j. constructs a sequence equal to the range [i,j).
Container operations cont. . .
a.insert(p,t) iterator a.insert(p,n,t) result is not used a.insert(p,i,j) result is not used a.erase(q) result is not used a.erase(q1,q2 result is ) not used inserts a copy of t before p. inserts n copies of t before p. inserts copies of elements in [i,j) before p. erases the element pointed to by q. eras...