Chapter 3

1. Chapter 3 DATA REPRESENTATION(2) L.Chen

2. 3.4.4 A 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. L.Chen

3. A 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. L.Chen

4. Program 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; }; L.Chen

5. Program 3.19 Outputting the integer chain X using a chain iterator int *x; ChainIterator <int > c; x = c.Initialize(X); while (x) { cout << *x << ' '; x = c.Next();} cout << endl; L.Chen

6. 3.4.5 Circular List Representation a chain is simplified and made to run faster by doing one or both of the following: • represent the linear list as a singly linked circular list (circular list) • add an additional node, called the head node at the front. L.Chen

7. Comparing Difference: head pointer ; head node L.Chen

8. firstNode a b c d e Circular List L.Chen

9. Program 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); }

10. 3.4.6 Comparison with Formula-Based Representation • formula-based representation:Continuous space; It iseasy to searchan element. • The procedures forinsertion and deletion are more complex. • Time Complexity to access kth element is Θ(1) • Chain and circular list representation:Therun timeof the Insert and delete from a linear list willbe smallerthan the formula-basedrepresentation. • Time Complexity to access kth element isO( k ). L.Chen

11. 3.4.7 Doubly Linked List Representation • 为什么要引入双向链表？ • 在单链表中，寻找下一个元素时间复杂度为O(1),寻找上一个元素时间复杂度为O(n)。为了克服单链表的缺点，引入双链表。 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（后继）. • 优点：可以向前、向后访问，效率高。 • 缺点：需要更多的空间，结构更复杂。 L.Chen

13. firstNode lastNode null null a b c d e Doubly Linked List L.Chen

14. firstNode a b c d e Doubly Linked Circular List L.Chen

15. headerNode a b c d e Doubly Linked Circular List With Header Node L.Chen

16. Empty Doubly Linked Circular List With Header Node headerNode L.Chen

17. Circular Doubly Linked List (双向循环链表) L D R a) Node b) Null List c) Circular Doubly Linked List L.Chen

18. 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 lists

19. Delete (k) 删除第k 个元素 = k (1) (2) e = p->data; p->prior->next = p->next; p->next->prior = p->prior; L.Chen

20. insert (k, x) 在第k个元素之前插入x = k (2) (4) (3) (1) S s->data =x; s->prior =p->prior; p->prior->next = s; s->prior =p; p->prior = s; L.Chen

21. 3.4.8 Summary • Chain • Singly linked circular list • Head node • Doubly linked list • Circular doubly linked list L.Chen

22. 3.5 Indirect Addressing 3.5.1 Representation • 间接寻址的定义、引入的目的。 • 如何实现间接寻址？ 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 list L.Chen

24. 3.5.2 Operations template <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 addressing 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 lists 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 list L.Chen

27. 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 list L.Chen

29. 3.6 Simulating Pointers L.Chen

30. c a e d b Simulated-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). L.Chen

31. Node Representation package dataStructures; class SimulatedNode { // package visible data members Object element; int next; // constructors not shown } L.Chen

32. How It All Looks c a e d b next • 14 11 14 -1 8 0 c a e d b element 0 1 2 3 4 5 8 11 14 firstNode = 4

33. Still Drawn The Same firstNode -1 a b c d e L.Chen

34. c a e d b firstNode Marking • 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. L.Chen

35. Start at firstNode and mark all nodes reachable from firstNode. Marking c c a a e e d d b e firstNode Repeat for all reference variables. L.Chen

36. Compaction Free Memory c a e d b e d b firstNode • Move all marked nodes (i.e., nodes in use) to one end of memory, updating all pointers as necessary. L.Chen

37. Simulated 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. L.Chen

38. 3.7 A Comparison L.Chen

39. Exercises Chapter3 Ex27; Ex31; Ex34; Ex37; Ex53 L.Chen