Linear List

Linked Representation

Linked Representation

• list elements are stored, in memory,

in an arbitrary order

• explicit information (called a link)

is used to go from one element to

the next

Memory Layout

a b c d e

c a e d b

A linked representation uses an arbitrary layout.

Layout of L = (a,b,c,d,e) using an array representation.

The figures show computer memory. An array uses a contiguous

chunk of memory.

Linked Representation

pointer (or link) in e is NULL

c a e d b

use a variable firstNode to get to the

first element a

firstNode

Normal Way To Draw A Linked List

link or pointer field of node

data field of node

a b c d e

NULL

firstNode

Chain

•A chain is a linked list in which each node

represents one element.

• There is a link or pointer from one element to

the next.

• The last node has a NULL pointer.

a b c d e

NULL

firstNode

Node Representation

template <class T>

struct chainNode

{

// data members

T element;

chainNode<T> *next;

// constructors come here

};

next

element

Constructors Of chainNode

chainNode() {}?

?

?

element

next

element

chainNode(const T& element)

{this->element = element;}

chainNode(const T& element, chainNode<T>* next)

{this->element = element;

this->next = next;}

get(0)

checkIndex(0);

desiredNode = firstNode; // gets you to first node

return desiredNode->element;

a b c d e

NULL

firstNode

Do a checkIndex first. Then move to desired node. Once you are at the desired node,

you can return the element in that node as in

return desiredNode.element;

When firstNode = null, there is no element whose index is 0.

get(1)

checkIndex(1);

desiredNode = firstNode->next; // gets you to second node

return desiredNode->element;

a b c d e

NULL

firstNode

get(2)

checkIndex(2);

desiredNode = firstNode->next->next; // gets you to third node

return desiredNode->element;

a b c d e

NULL

firstNode

get(5)

checkIndex(5); // throws exception

desiredNode = firstNode->next->next->next->next->next;

// desiredNode = NULL

return desiredNode->element; // NULL.element

a b c d e

NULL

firstNode

Get(theIndex)

• Check theIndex

• currentNode = firstNode

• For (i=0; i<theIndex;i++)

– currentNode = currentNode->next;

• Return currentNode->element

Erase An Element

erase(0)

a b c d e

NULL

firstNode

deleteNode = firstNode;

firstNode = firstNode->next;

delete deleteNode;

a b d e

NULL

firstNode

c

erase(2)

first get to node just before node to be removed

cc

beforeNode = firstNode->next;

b

beforeNode

erase(2)

save pointer to node that will be deleted

deleteNode = beforeNode->next;

beforeNode

a b c d e

null

firstNode

erase(2)

now change pointer in beforeNode

beforeNode->next = beforeNode->next->next;

delete deleteNode;

beforeNode

a b c d e

null

firstNode

Erase(theIndex)

• Check theIndex

• If theIndex == 0

– Delete firstNode

– firstNode = firstNode->next

• Else

– Find beforeNode

– deleteNode = beforeNode->next;

– beforeNode->next = beforNode->next->next

– Delete deleteNode

• listSize--

insert(0,’f’)

a b c d e

NULL

firstNode

f

newNode

Step 1: get a node, set its data and link fields

newNode = new chainNode<char>(theElement,

firstNode);

insert(0,’f’)

a b c d e

NULL

firstNode

f

newNode

Step 2: update firstNode

firstNode = newNode;

One-Step insert(0,’f’)

a b c d e

NULL

firstNode

f

newNode

firstNode = new chainNode<char>(‘f’, firstNode);

insert(3,’f’)

• first find node whose index is 2

a b c d e

NULL

firstNode

f

newNode

beforeNode

c

• next create a node and set its data and link fields

chainNode<char>* newNode = new chainNode<char>( ‘f’,

beforeNode->next);

• finally link beforeNode to newNode

beforeNode->next = newNode;

Two-Step insert(3,’f’)

beforeNode = firstNode->next->next;

beforeNode->next = new chainNode<char>

(‘f’, beforeNode->next);

a b c d e

NULL

firstNode

f

newNode

beforeNode

c

Insert(theIndex, theElement)

• Check theIndex (0-listSize)

• If theIndex == 0

– create newNode

– newNode = firstNode

• Else

– Create newNode

– Find the beforeNode

– newNode->next = beforeNode->next

– beforeNode->next = newNode

• listSize++

Other chain structures

Chain With Header Node

a b c d e

NULL

headerNode

a b c d e

NULL

firstNode

insert/erase code is simplified

Empty Chain With Header Node

headerNode

NULL

The Class chainWithHeader

template<class T>

class chainWithHeader : public linearList<T>

{

public:

// other ADT methods defined here

protected:

void checkIndex(int theIndex) const;

chainNode<T>* HeaderNode;

int listSize;

};

Circular List

a b c d e

firstNode

Insert(0,’f’)

insert(listSize,’g’)

erase(0)

erase(listSize-1)

a b c d e

firstNode

Doubly Linked List

a b c d e

NULL

firstNode

NULL

lastNode

Node Representation

template <class T>

struct doublyChainNode

{

// data members

T element;

chainNode<T> *previous;

chainNode<T> *next;

// constructors come here

};

next

element

previous

Insert(0,’f’)

insert(listSize,’g’)

erase(0)

erase(listSize-1)

a b c d e

NULL

firstNode

NULL

lastNode

Doubly Linked Circular List

a b c d e

firstNode

Insert(0,’f’)

insert(listSize,’g’)

erase(0)

erase(listSize-1)

a b c e

headerNode

d

Doubly Linked Circular List With Header Node

a b c e

headerNode

d

Empty Doubly Linked Circular List With Header Node

headerNode

The STL Class list/vector

Linked implementation of a linear list.

Doubly linked circular list with header node.

Has many more methods than chain.

Similar names and signatures.

Lab 4