2004-03 L.Chen 1

Chapter 3Chapter 3

DATA DATA REPRESENTATION(2)REPRESENTATION(2)

2004-03 L.Chen 2

3.4.4 3.4.4 A Chain Iterator ClassA Chain Iterator Class( 遍历器类 ) An iterator permits you to

examine the elements of a data structure one at a time.

Suppose for a moment that Output( ) is not a member function of Chain and that << is not overloaded for this class.

2004-03 L.Chen 3

A Chain Iterator ClassA Chain Iterator Class

int len = x.length( ); for ( int i=1; i<=len; i++) { x.find(i,x); Cout<< x<< ‘‘ ;}

the complexity of this code is Θ ( n2), the Output() is Θ( n)An iterator records the current position

and advance one position right each time.

2004-03 L.Chen 4

Program 3.18 Chain iterator classProgram 3.18 Chain iterator class template<class T> class ChainIterator{public: T* Initialize (const Chain<T>& c) { location = c.first; if (location) return &location->data; return 0; } T* Next ( ) { if (!location) return 0; location = location->link; if (location) return &location->data; return 0; }private: ChainNode<T> *location; };

2004-03 L.Chen 5

Program 3.19 Outputting the integer chain X using a Program 3.19 Outputting the integer chain X using a chain iteratorchain iterator

int *x;

ChainIterator <int > c;

x = c.Initialize(X);

while (x) { cout << *x << ' '; x = c.Next();}

cout << endl;

2004-03 L.Chen 6

3.4.5 3.4.5 Circular List RepresentationCircular List Representation

a chain is simplified and made to run

faster by doing one or both of thefollowing:

1) represent the linear list as a singly linked circular list (circular list)

2) add an additional node, called the head node at the front.

2004-03 L.Chen 7

Comparing Difference: head pointer ; head node

2004-03 L.Chen 8

Circular ListCircular List

a b c d e

firstNode

Program 3.20 Searching a circular linked list with head nodeProgram 3.20 Searching a circular linked list with head node template <class T>int CircularList <T> : : Search(const T& x) const{ // Locate x in a circular list with head node.

ChainNode<T> *current = first->link; int index = 1; // index of current

first->data = x; // put x in head node

// search for x

while (current->data != x) { current = current->link; index++; } // are we at head?

return ((current == first) ? 0 : index); }

2004-03 L.Chen 10

3.4.6 3.4.6 Comparison with Formula-Based Comparison with Formula-Based RepresentationRepresentation

formula-based representation: Continuous space; It is easy to search an element.

The procedures for insertion and deletion are more complex.

Time Complexity to access kth element is Θ(1)

Chain and circular list representation:The run time of the Insert and delete from a linear list will be smaller than the formula-based representation.

Time Complexity to access kth element is O( k ).

2004-03 L.Chen 11

3.4.7 3.4.7 Doubly Linked List RepresentationDoubly Linked List Representation

为什么要引入双向链表？

在单链表中，寻找下一个元素时间复杂度为O(1), 寻找上一个元素时间复杂度为 O(n) 。为了克服单链表的缺点，引入双链表。

2004-03 L.Chen 12

链表的具体结构

A doubly linked list is an ordered sequence of nodes in which each node has two pointers: left pointer ( 前趋 ) and right pointer （后继） .

优点：可以向前、向后访问，效率高。 缺点：需要更多的空间，结构更复杂。

2004-03 L.Chen 13

Doubly Linked ListDoubly Linked List

a b c d enull

firstNode

null

lastNode

2004-03 L.Chen 14

Doubly Linked Circular ListDoubly Linked Circular List

a b c d e

firstNode

2004-03 L.Chen 15

Doubly Linked Circular List With Header NodeDoubly Linked Circular List With Header Node

a b c e

headerNode

d

2004-03 L.Chen 16

Empty Doubly Linked Circular List Empty Doubly Linked Circular List With Header NodeWith Header Node

headerNode

2004-03 L.Chen 17

Circular Doubly Linked ListCircular Doubly Linked List ( 双向循环链表 )

a) Node b) Null List

c) Circular Doubly Linked List

L D R

template<class T> class DoubleNode{

friend Double<T>;

private: T data; DoubleNode<T> *left, *right; };

template<class T> class Double{

public: Double() { LeftEnd=RightEnd=0; };

~Double();

int Length()const; bool Find (int k, T& x) const ;

int Search (const T& x) const ;

Double<T>& Delete (int k, T& x);

Double<T>& Insert (int k, const T& x);

void Output (ostream& out) const ;

private : DoubleNode<T> *LeftEnd, *RightEnd; };

Program 3.21 Class definition for doubly linked listsProgram 3.21 Class definition for doubly linked lists

2004-03 L.Chen 19

(1)

(2)

Delete (k) 删除第 k 个元素

e = p->data;

p->prior->next = p->next;

p->next->prior = p->prior;

= k

2004-03 L.Chen 20

insert (k, x) 在第 k 个元素之前插入 x

(1)(2)

(3)(4)

s->data =x;

s->prior =p->prior; p->prior->next = s;

s->prior =p; p->prior = s;

S

= k

2004-03 L.Chen 21

3.4.8 3.4.8 SummarySummary

Chain Singly linked circular list Head node Doubly linked list Circular doubly linked list

2004-03 L.Chen 22

3.5 3.5 Indirect AddressingIndirect Addressing

3.5.1 3.5.1 RepresentationRepresentation 间接寻址的定义、引入的目的。 如何实现间接寻址？

2004-03 L.Chen 23

template<class T> class IndirectList{

public: IndirectList(int MaxListSize=10);

~IndirectList( );

bool IsEmpty( )const {return length==0;}

int Length( )const {return length;}

bool Find(int k,T& x) const ;

int Search(const T& x) const ;

IndirectList<T>& Delete(int k, T& x);

IndirectList<T>& Insert(int k, const T& x);

void Output(ostream& out) const ;

private:T **table; // 1D array of T pointers

int length, MaxSize; };

Program 3.22 Class definition for an indirectly addressed listProgram 3.22 Class definition for an indirectly addressed list

2004-03 L.Chen 24

3.5.2 3.5.2 OperationsOperationstemplate <class T>IndirectList<T>:: indirectList (int MaxListSize){ MaxSize = MaxListSize;

table = new T *[MaxSize]; length = 0; }template <class T>IndirectList<T>:: ~indirectList( ){ for (int i = 0; i < length; i++)

delete table[i]; delete [ ] table; }

Program 3.23 Constructor and destructor for indirect addressingProgram 3.23 Constructor and destructor for indirect addressing

2004-03 L.Chen 25

template <class T>

bool IndirectList<T>::Find(int k, T& x) const

{ if (k < 1 || k > length) return false;

x = *table[k - 1];

return true;

}

Program 3.24 Find operation for indirect listsProgram 3.24 Find operation for indirect lists

2004-03 L.Chen 26

template <class T>

IndirectList<T>& IndirectList<T>::Delete(int k,T& x)

{ if (Find(k, x))

{ for (int i = k; i < length; i++)

table[i-1] = table[i];

length--; return *this ; }

else throw OutOfBounds( );

}

Program 3.25 Deletion from an indirect listProgram 3.25 Deletion from an indirect list

2004-03 L.Chen 27

2004-03 L.Chen 28

template <class T>

IndirectList<T>& IndirectList<T>::Insert(int k, const T& x)

{ if (k < 0 || k > length) throw OutOfBounds();

if (length == MaxSize) throw NoMem( );

for (int i = length-1; i >= k; i--) table[i+1] = table[i];

table[k] = new T; *table[k] = x;

length++; return *this ;

}

Program 3.26 Insertion into an indirectly addressed listProgram 3.26 Insertion into an indirectly addressed list

2004-03 L.Chen 29

3.6 3.6 Simulating PointersSimulating Pointers

2004-03 L.Chen 30

Simulated-Pointer Memory LayoutSimulated-Pointer Memory Layout

Data structure memory is an array, and each array position has an element field (type Object) and a next field (type int).

c a e d b

2004-03 L.Chen 31

Node RepresentationNode Representation

package dataStructures;

class SimulatedNode

{ // package visible data members

Object element;

int next;

// constructors not shown

}

How It All LooksHow It All Looks

14

c a e d b

c a e d b

0 1 2 3 4 5 8 11 14

14 011 8-1

firstNode = 4

next

element

2004-03 L.Chen 33

Still Drawn The SameStill Drawn The Same

a b c d e-1

firstNode

2004-03 L.Chen 34

MarkingMarking

Unmark all nodes (set all mark bits to false).

Start at each program variable that contains a reference, follow all pointers, mark nodes that are reached.

c a e d b

firstNode

2004-03 L.Chen 35

MarkingMarking

c a e d b

firstNode

c a e d e

Repeat for all reference variables.

Start at firstNode and mark all nodes reachable from firstNode.

2004-03 L.Chen 36

CompactionCompaction

Move all marked nodes (i.e., nodes in use) to one end of memory, updating all pointers as necessary.

c b e d b

firstNode

a e d Free Memory

2004-03 L.Chen 37

Simulated PointersSimulated Pointers Can allocate a chain of nodes

without having to relink.

Can free a chain of nodes in O(1) time when first and last nodes of chain are known.

2004-03 L.Chen 38

3.7 3.7 A ComparisonA Comparison

2004-03 L.Chen 39

ExercisesExercises

Chapter3

Ex27; Ex31; Ex34;

Ex37; Ex53