1 chapter 4 list 、 stack 、 queue content: list stack queue
TRANSCRIPT
1
Chapter 4List 、 stack 、 queue
Content:
• list
• stack
• queue
2
Lists
A list is a finite, ordered sequence of data elements.
Important concept: List elements have a position.
Notation:
<a0, a1, …, an-1>
< >
ai denotes a list elementn >= 0 is finitelist size is n
Data 1 Data 1 Data 2 Data 2 Data 3 Data 3 Data n Data n
head tailEmpty List
Sorted list
<1,3,5,6,8,9,21,24,56,77>
<98,65,43,23,11,10,9,6,5,4,2>
Unsorted list
<1,6,3,9,34,30,19,8,12,44>
3
List Operations----What operations should we
implement?
L = (a,b,c,d,e)• Setnull （）• Prior （）• Next （）• Insert( 2,h)• Remove( 3)• get （ 4 ）
4
current position and fence
Our list implementation will support the concept of a current position.
We will do this by defining the list in terms of left and right partitions.
• Either or both partitions may be empty.
Partitions are separated by the fence.
<20, 23 | 12, 15> <20, 23 | 10,12, 15>
abstract
6
List ADTtemplate <class Elem> class List {public: virtual void clear() = 0; virtual bool insert(const Elem&) = 0; virtual bool append(const Elem&) = 0; virtual bool remove(Elem&) = 0; virtual void setStart() = 0; virtual void setEnd() = 0;
7
List ADT (cont)
virtual void prev() = 0; virtual void next() = 0; virtual int leftLength()const = 0; virtual int rightLength()const = 0; virtual bool setPos(int pos)= 0; virtual bool getValue(Elem&)const = 0;
virtual void print() const = 0;};
8
Array-Based List
list physical implementation
array-based list linked list
9
Array-Based List (cont)
element element
A0 A1 … …… … An-2 An-1 A0 A1 … …… … An-2 An-1
An
……..
Ai
……..
A2
A1Lo
Lo+m
Lo+(i-1)*m
Lo+ （ n-1)*m
address value
Loc(a)=Lo+i*m
Given some position in the list
10
Array-Based List Classtemplate <class Elem> // Array-based listclass AList : public List<Elem> {private: int maxSize; // Maximum size of list int listSize; // Actual elem count int fence; // Position of fence Elem* listArray; // Array holding listpublic: AList(int size=DefaultListSize) { maxSize = size; listSize = fence = 0; listArray = new Elem[maxSize]; } ~AList() { delete [] listArray; }
11
Array-Based List Class (2)void clear() { delete [] listArray; listSize = fence = 0; listArray = new Elem[maxSize];}Bool insert(const Elem&);Bool append(const Elem&);Bool remove(Elem&);void setStart() { fence = 0; }void setEnd() { fence = listSize; }void prev() { if (fence != 0) fence--; }void next() { if (fence <= listSize) fence++; }int leftLength() const { return fence; }int rightLength() const { return listSize - fence; }
12
Array-Based List Class (3)bool setPos(int pos) { if ((pos >= 0) && (pos <= listSize)) fence = pos; return (pos >= 0) && (pos <= listSize);
}
bool getValue(Elem& it) const { if (rightLength() == 0) return false; else { it = listArray[fence]; return true; }}Void print()const{ int temp=0; Cout<<“<”; while(temp<fence)cout<<listArray [temp++]<<“ ”; cout<<“|”; while(temp>fence)cout<<listArray [temp++]<<“ ”; cout<<“>\n”;}}
Most of the other member functions for class
alist simply access the current list element or
move the position of the fence.such operations
all require (1) time.
13
Array-Based List Insert
(n)
Figure 4.4
14
Insert//Insert at front of right partitiontemplate <class Elem>bool AList<Elem>::insert(const Elem& item) {
if (listSize == maxSize) return false;
for(int i=listSize; i>fence; i--) // Shift Elems up to make room listArray[i] = listArray[i-1]; listArray[fence] = item; listSize++; // Increment list size return true; }
fence
15
Append// Append Elem to end of the list
template <class Elem>
bool AList<Elem>::append(const Elem& item)
{
if(listSize==maxSize)return false;
listArray[listSize++]=item;
return true;
}
fence
(n)
16
Remove//Remove and return first Elem in right// partitiontemplate <class Elem>bool AList<Elem>::remove(Elem& it) { if (rightLength() == 0) return false; it = listArray[fence]; // Copy Elem for(int i=fence; i<listSize-1; i++) // Shift them down listArray[i] = listArray[i+1]; listSize--; // Decrement size return true; }
17
[Exp 4-1] prints screen “China”#include "sj_List.h"#include "sj_Alist.h"#include "iostream.h"void main(void){ sj_AList<char> l1(10); char ch; l1.insert('C'); l1.insert('h'); l1.insert('i'); l1.insert('n'); l1.insert('a'); l1.setPos(4); for(int i=0;i<5;i++) { l1.getValue(ch);cout<<ch; l1.prev(); } cout<<"\n"; l1.print(); cout<<"\n";}
18
[Exp 4-2] merges A and B
sorted list descend
#include "sj_List.h"#include "sj_Alist.h"#include "iostream.h"void mergelist(sj_Alist<int> &A,sj_AList<int> &B, sj_AList<int> *C){ int ii=0,jj=0,iend,jend,ai,bj; A.setPos(0); B.setPos(0); iend=A.rightLength(); jend=B.rightLength(); while(ii<iend&&jj<jend) { A.getValue(ai); B.getValue(bj);
if(ai<bj){C->insert(ai); A.next();ii++; } else{C->insert(bj);B.next();jj++; } }
19
[Exp 4-2 ] (cont) while(ii++<iend)
{A.getValue(ai);C->insert(ai);A.next();} while(jj++<jend)
{B.getValue(bj);C->insert(bj);B.next();}}void main(){ sj_AList<int> la(5); sj_AList<int> lb(10); sj_AList<int> lc(15); for(int i=9;i>0;i=i-2) la.insert(i); for(int j=18;j>=2;j=j-2) lb.insert(j);
20
[Exp 4-2 ] (cont)
la.print();
cout<<"\n";
lb.print();
cout<<"\n";
mergelist(la,lb,&lc);
lc.print();
cout<<"\n";}
21
Homework1
1. 试用顺序表作为存储结构，变成实现线性表（ a0, a1, a2, a3, …,an-1 ）就地逆置的操作。 2. 设顺序表 L 是一个递增有序表。试用顺序表作为存储结构，编程实现将 x 插入 L 表中，并使 L 仍是一个有序表。 3. 利用顺序表，实现统计在一个输入字符串中各个不同字符出现的频度。
22
Linked List ----What is linked list? • A series of data items: a1, a2, a3, a4, …
• Each data item has a link to the next one.
• Two pointers are required. One for the head of the list and another for the tail of the list
• In a list, which is a kind of data type, the operation includes: add/remove from two ends of the list, insert/delete in the middle of the list.
23
dn ^WANG SUNSUN ... LI LI
tail
headNo a header node used
WANG ... SUN SUN
tailhead
Using a header node
24
Link Class
// Singly-linked list nodetemplate <class Elem> class Link {public: Elem element; // Value for this node Link *next; // Pointer to next node Link(const Elem& elemval, Link* nextval =NULL) { element=elemval; next=nextval; } Link(Link* nextval =NULL) { next = nextval; }};
Dynamic allocation of new list elements
element next
25
template <class Elem> class Llist;template <class Elem> class Link{friend class Llist<Elem>; private: Elem element; // Value for this node Link *next; // Pointer to next node public: Link(const Elem& elemval,Link* nextval=NULL)
{ element=elemval; next=nextval; }
Link(Link* nextval =NULL) { next = nextval; }};
Link Class
26
List Model
head
tailInsert an item to a list
S->next=P->next P->next=S
P
27
Delete an item in a list
head tail
List Model
P->next=P->next->next ->next
28
Linked List Position (1)
previous point ?
29
Linked List Position (2)
30
Linked List Class (1)// Linked list implementationtemplate <class Elem> class LList:
public List<Elem> {private: Link<Elem>* head; // Point to list header Link<Elem>* tail; // Pointer to last Elem Link<Elem>* fence;// Last element on left
int leftcnt; // Size of left int rightcnt; // Size of right void init() // Intialization routine { fence = tail = head = new Link<Elem>; leftcnt = rightcnt = 0; }
31
Linked List Class (2)void removeall() // Return link nodes to { free store
while(head != NULL) { fence = head; head = head->next; delete fence; } }public: LList(int size=DefaultListSize){ init(); }
~LList() { removeall(); } // Destructor void clear() { removeall(); init(); }Bool insert(const Elem&);Bool append(const Elem&);Bool remove(Elem&);
32
Linked List Class (3)
void setStart() { fence = head;
rightcnt += leftcnt;leftcnt = 0; }
void setEnd() { fence = tail;
leftcnt += rightcnt;rightcnt = 0; }
Void prev();
Bool setPos(int pos);
void next()
{if(fence!=tail){fence=fence->next;
rightcnt--; leftcnt++; }
}
Don't move fence if
right empty
33
Linked List Class (4)
int leftLength() const { return leftcnt; }int rightLength() const { return rightcnt; }bool getValue(Elem& it) const { if(rightLength() == 0) return false; it = fence->next->element; return true; }Void print()const;}
34
anai
a1 a2
ai-1
h
fence
S xS x
Insert/Append
fence anai
a1 a2
ai-1
head
S
35
Insert/Append (cont)
// Insert at front of right partitiontemplate<class Elem>bool LList<Elem> ::insert(const Elem& item) {fence->next= new Link<Elem>(item, fence->next);
if(tail==fence) tail=fence->next; rightcnt++; return true;}
36
Removal
37
Remove (cont)
// Remove and return first Elem in right// partitiontemplate <class Elem> bool LList<Elem>::remove(Elem& it) {
if (fence->next == NULL) return false; it = fence->next->element; // Remember val // Remember link node Link<Elem>* ltemp = fence->next; fence->next = ltemp->next; // Remove if (tail == ltemp) // Reset tail tail = fence; delete ltemp; // Reclaim space rightcnt--; return true;}
38
//Append Elem to end of the listtemplate <class Elem> bool LList<Elem>::append(const Elem& item){tail=tail->next=new Link<Elem>(item,NULL); rightcnt++; return true;}// Move fence one step left;// no change if left is emptytemplate <class Elem> voidLList<Elem>::prev() { Link<Elem>* temp = head; if(fence==head) return; //No prev Elem while(temp->next!=fence) temp=temp->next; fence=temp; leftcnt--; rightcnt++;}
Previous
Append
39
setPos// Set the size of left partition to pos
template <class Elem>bool LList<Elem>::setPos(int pos) {if((pos<0)||(pos>rightcnt+leftcnt)) return false; fence=head; for(int i=0;i<pos;i++) fence=fence->next; return true;}
40
Printtemplate <class Elem>void LList<Elem>::Print()const {Link<Elem>*temp=head; Cout<<“<”; while(temp!=fence) {cout<<temp->next->element<<“”; temp=temp->next; } cout<<“|”; while(temp->next!=NULL) {cout<<temp->next->element<<“”; temp=temp->next; } cout<<“>\n”;}
41
[Exp 4-3] Programming:
inserts five numbers of the
integer to empty linked list,
and sums up all elements of
this list. Exp4-3.cpp
42
[Exp 4-4]
Programming a function of Locate:
Finds i’th node in linked list– success:
print the address and the value
of i’th node– unsuccess :
return NULL
Locate:
Exp4-4
43
Homework2
1. 试用单链表作为存储结构，变成实现线性表（ a0, a1, a2, a3, …,an-1 ）就地逆置的操作。 2. 设单链表 L 是一个递增有序表。试用顺序表作为存储结构，编程实现将 x 插入 L 表中，并使 L 仍是一个有序表。 3. 利用单链表，实现统计在一个输入字符串中各个不同字符出现的频度。
44
Homework2 （ cont ）4. 已知 L1 和 L2 分别指向两个单链表的头结点，且已知其长度分别为 m 和 n 。试编程实现将这两个链表连接在一起。5. 设 A 和 B 是两个单链表，其表中元素递增有序。试编程将 A 和 B 归并成一个按元素值递增有序的单链表 C 。6. 设有一个表头指针为 h 的单链表。试设计一个算法，通过遍历一趟链表，将链表中所有结点的链接方向逆转。要求逆转结果链表的头指针 h 指向原链表的最后一个结点。7. 根据一个结点数据类型为整型的单链表生成两个单链表，使得第一个单链表中包含原单链表中所有数值为奇数的结点，使得第一个单链表中包含原单链表中所有数值为偶数的结点，原单链表保持不变。
45
Head Tail
Circularly Linked List
46
Freelists
• A freelist holds those list nodes that are not currently being used
• When a new element is to be added to a linked list,the freelist is checked to see if a list node is available.
• Instead of making repeated calls to new and delete,the link class can handle its own freelist.
47
The Link Class With a Freelist--System new and delete are slow
// Singly-linked list node with freelisttemplate <class Elem> class Link {private:
static Link<Elem>* freelist; // Headpublic: Elem element; // Value for this node Link* next; // Point to next node Link(const Elem& elemval,Link* nextval=NULL)
{ element=elemval; next=nextval; } Link(Link* nextval=NULL) {next=nextval;}
void* operator new(size_t); // Overload void operator delete(void*); // Overload};
48
The Link Class With a Freelist (cont)template <class Elem>Link<Elem>* Link<Elem>::freelist = NULL;template <class Elem> // Overload for newvoid* Link<Elem>::operator new(size_t) { if (freelist == NULL) return ::new Link; Link<Elem>* temp = freelist; // Reuse freelist = freelist->next; return temp; // Return the link}template <class Elem> // Overload deletevoid Link<Elem>::operator delete(void* ptr){((Link<Elem>*)ptr)->next = freelist; freelist = (Link<Elem>*)ptr;}
49
Comparison of ImplementationsArray-Based Lists:• Insertion and deletion are (n).• Prev and direct access are (1).• Array must be allocated in advance.• No overhead if all array positions are
full.
Linked Lists:• Insertion and deletion are (1).• Prev and direct access are (n).• Space grows with number of elements.• Every element requires overhead.
50
Space Comparison
“ Break-even” point:
DE = n(P + E);
n = DE P + E
E: Space for data value.P: Space for pointer.D: Number of elements in array.
51
Doubly Linked Lists
A doubly linked list is
designed to allow
convenient access from a
list node to the next node
and also to the preceding
node on the list.
52
Doubly Linked List
Data
Next
Prev
Data
Next
Prev
Data
Next
PrevNULL
NULL
HeadTail
53
Doubly Linked ListsSimplify insertion and deletion: Add a prev pointer.
// Doubly-linked list link nodetemplate <class Elem> class Link {public: Elem element; // Value for this node Link *next; // Pointer to next node Link *prev; // Pointer to previous node Link(const Elem& e, Link* prevp =NULL, Link* nextp =NULL) { element=e; prev=prevp; next=nextp; } Link(Link* prevp =NULL, Link* nextp =NULL) { prev = prevp; next = nextp; }};
54
Doubly Linked Insert
55
Doubly Linked Insert
// Insert at front of right partitiontemplate <class Elem>bool LList<Elem>::insert(const Elem& item) { fence->next = new Link<Elem>(item, fence, fence->next); if (fence->next->next != NULL) fence->next->next->prev = fence->next; if (tail == fence) // Appending new Elem tail = fence->next; // so set tail rightcnt++; // Added to right return true;}
56
Doubly Linked Remove
57
Doubly Linked Remove// Remove, return first Elem in right parttemplate <class Elem>bool LList<Elem>::remove(Elem& it) { if (fence->next == NULL) return false; it = fence->next->element; Link<Elem>* ltemp = fence->next; if (ltemp->next != NULL) ltemp->next->prev = fence; else tail = fence; // Reset tail fence->next = ltemp->next; // Remove delete ltemp; // Reclaim space
rightcnt--; // Removed from right return true;}
58
Homework3
1. 设计一个实现下述要求的定位函数 Locate() 。
设有一个带表头结点的双向链表 L ，每个结点有 4个数据成员：前驱指针 prev 、后继指针 next 、数据Data 和访问频度 freq 。所有节点的 freq 初始值都为0 。每当在链表上进行依次 locate(L,x) 操作时，令元素值为 x 的结点的访问频度 freq 加 1 ，并将该结点前移，连接到与它的访问频度相等的结点后面，使得链表中所有的结点保持按访问频度递减的顺序排列，以使频繁被访问的结点总是靠近表头。
Locate
59
Homework3 （ cont ）
2. 利用双向循环链表的操作，解决约瑟夫问题。
Josephus question ： 设 n 个人围成一个圆圈，按一指定方向，从第s 个人开始报数，报数到 m 为止，报数为 m 的人出列，然后，从下一个开始重新报数，报数到 m的人又出列，…，直到所有的人全部出列为止。
Josephus question 要对任意给定的 n 、 s 和m ，求按出列次序得到的人员顺序表。
Josephus
60
Homework3 （ cont ）
3. 集合运算。 由集合运算的定义知，（ A-B ∪） （ B-A ）的结果是 A 与 B 的非公共部分所构成的集合。
Sets
61
Dictionary
Often want to insert records, delete records, search for records.
Required concepts:• Search key: Describe what we are
looking for• Key comparison
– Equality: sequential search– Relative order: sorting
• Record comparison
62
Dictionary ADT
// The Dictionary abstract class.template <class Key, class Elem, class KEComp, class EEComp>class Dictionary {public: virtual void clear()=0; virtual bool insert(const Elem&)=0; virtual bool remove(const Key&,Elem&)=0; virtual bool removeAny(Elem&)=0; virtual bool find(const Key&,Elem&)const=0; virtual int size()=0;};
63
Comparator Class
How do we generalize comparison?• Use ==, <=, >=: Disastrous• Overload ==, <=, >=: Disastrous• Define a function with a standard name
– Implied obligation– Breaks down with multiple key
fields/indices for same object• Pass in a function
– Explicit obligation– Function parameter– Template parameter
64
Comparator Example
class intintCompare {public: static bool lt(int x, int y) { return x < y; } static bool eq(int x, int y) { return x == y; } static bool gt(int x, int y) { return x > y; }};
65
Comparator Example (cont)
class Payroll { public: int ID; char* name;};class IDCompare {public: static bool lt(Payroll& x, Payroll& y) { return x.ID < y.ID; } static bool eq(Payroll& x, Payroll& y) { return x.ID == y.ID; } static bool gt(Payroll& x, Payroll& y) { return x.ID > y.ID; }};
66
Comparator Example (cont)
class NameCompare
{public:
static bool lt(Payroll& x,Payroll& y)
{return strcmp(x.name,y.name)<0;}
static bool eq(Payroll& x,Payroll& y)
{return strcmp(x.name,y.name)==0;}
static bool gt(Payroll& x,Payroll& y)
{return strcmp(x.name,y.name)>0;}
};
67
Unsorted List Dictionary
#include "dictionary.h"
template <class Key, class Elem, class KEComp, class EEComp>
class UALdict : public Dictionary<Key,Elem,KEComp,EEComp>
{private:
AList<Elem>* list;
public:
UALdict(int size=DefaultListSize)
{ list = new AList<Elem>(size); }
~UALdict() { delete list; }
68
Unsorted List Dictionary (cont)
void clear() { list->clear(); }
bool insert(const Elem& e)
{ return list->append(e); }
bool remove(const Key& K, Elem& e)
{for(list->setStart();
list->getValue(e);list->next())
if (KEComp::eq(K, e))
{list->remove(e); return true; }
return false;
}
69
Unsorted List Dictionary (cont)
bool removeAny(Elem& e)
{if (size() == 0) return false;
list->setEnd(); list->prev();
list->remove(e); return true;
}
70
Unsorted List Dictionary (cont)
bool find(const Key& K,Elem& e)const { for(list->setStart(); list->getValue(e);list->next()) if (KEComp::eq(K,e))return true; return false; } int size() {return list->leftLength() +list->rightLength(); }};
71
Sorted array-based listtemplate <class Elem, class Compare>class SAList: protected AList<Elem> {public: SAList(int size=DefaultListSize) : AList<Elem>(size) {} ~SAList() {} AList<Elem>::clear; bool insert(const Elem& item) {Elem curr; for (setStart();getValue(curr);next()) if(!Compare::lt(curr, item)) break; return AList<Elem>::insert(item); }
72
Sorted array-based list(cont)
AList<Elem>::remove; AList<Elem>::setStart; AList<Elem>::setEnd; AList<Elem>::prev; AList<Elem>::next; AList<Elem>::leftLength; AList<Elem>::rightLength; AList<Elem>::setPos; AList<Elem>::getValue; AList<Elem>::print;};
73
Dictionary implemented with a sorted array-based
listtemplate <class Key, class Elem, class KEComp, class EEComp> class SALdict : public ictionary<Key,Elem,KEComp,EEComp>
{private:
SAList<Elem, EEComp>* list;
public:
SALdict(int size=DefaultListSize)
{list=new SAList<Elem, EEComp>(size);}
~SALdict() { delete list; }
74
Dictionary implemented with a sorted array-based
list(cont) void clear() { list->clear(); } bool insert(const Elem& e) { return list->insert(e); } bool remove(const Key& K, Elem& e) {for (list->setStart(); list->getValue(e); list->next()) if(KEComp::eq(K, e)) {list->remove(e);return true;} return false; }
75
Dictionary implemented with a sorted array-based
list(cont)bool removeAny(Elem& e){if(size()==0) return false; list->setEnd(); list->prev(); list->remove(e);return true;}bool find(const Key& K, Elem& e) const{int l=-1; int r=list->leftLength() +list->rightLength();
76
Dictionary implemented with a sorted array-based
list(cont) while (l+1 != r) {int i = (l+r)/2; list->setPos(i);list->getValue(e); if (KEComp::lt(K,e)) r=i; if (KEComp::eq(K,e)) return true; if (KEComp::gt(K, e)) l = i; } return false; } int size() { return list->leftLength() + list->rightLength(); }};
77
Stacks---- What is stack?
• A stack is a list with the restriction that
insertions and deletions can be
performed in only one position. The end
of the list is called the top. The
fundamental operations on a stack are
push = insert, and pop = delete.
78
Stacks (cont)
LIFO: Last In, First Out.
Restricted form of list: Insert and remove only at front of list.
Notation:
• Insert: PUSH
• Remove: POP
• The accessible element is called TOP.
79
Stack Model
A
B
….
MM
push pop
top
bottom
1.Operations:
• Top: get the pointer
• Pop: delete data
• Push: insert data
2.Features of Stack:
• Last -In- First–Out
• Only one pointer
80
10
S[4]
23
10 ba
ses[top]=xtop=top+1
top
10
25
30
S[4]
23
10
top
base top=top-
1x=s[top]
Stack is
empty
Push 10
(insert)
30 Pop
(delete)
S[4]
23
10
Top=0
top
Stack is full
top=stacksize
10
25
30
40S[4]
23
10
top=4
base
Main stack operations:
underflow overflow
81
Stack ADT
STACK ADT ??
// Stack abtract classtemplate <class Elem> class Stack {public: virtual void clear() = 0; virtual bool push(const Elem&) = 0; virtual bool pop(Elem&) = 0; virtual bool topValue(Elem&) const = 0; virtual int length() const = 0;};
82
Array-Based Stack// Array-based stack implementationprivate: int size; // Maximum size of stack int top; // Index for top element Elem *listArray;//Array holding elements
Issues:• Which end is the top?• Where does “top” point to?• What is the cost of the operations?
‘a’ ‘b’ ‘g’ ‘3’ ‘f’
top0 1 2 3 4 5
83
Array-Based Stack(cont) ┋Bool push(const Elem & item)
{ if(top==size)return false;
else {listArray[top++]=item;
return true; }
}
Bool pop( Elem & it)
{ if(top==0)return false;
else {it=listArray[--top];
return true; }
} ┋
84
private:
Link<Elem>* top; //Pointer to first elem
int size; //Count number of elems
• What is the cost of the operations?• How do space requirements compare to the
array-based stack implementation?
Linked Stack
top
Linked stack implementation
85
#include "link.h"#include "stack.h"template <class Elem> class LStack: public Stack<Elem> { bool push(const Elem& item) { top = new Link<Elem>(item, top); size++; return true; }
};
P
base
S
bS
86
Comparison of array-based and linked stack
• Time: Both take constant time.
• Space:
– The array-based stack must declare a fixed-size array initially,and some of that space is wasted whenever the stack is not full.
– The linked stack can shrink and grow but requires the overhead of a link field for every element.
87
Applications of Stacks
top1 top2top1top1top1top1 top2top2top2
Two stacks implemented within in a single array,both growing toward the middle
88
Applications of Stacks
• Direct applications
– Page-visited history in a Web browser
– Undo sequence in a text editor
– Chain of method calls in the Java Virtual Machine
• Indirect applications
– Auxiliary data structure for algorithms
– Component of other data structures
89
Example of Stacks App——a function call
MAIN{ }
CALL fun(parameter)
END
fun(parameter)
return
① ②
⑤
⑦⑧
ParameterCurrent LocaleReturn Address
③
⑥
push④
Current Locale
Return Address
Current Locale Return Address
Parameter
pop
pop
90
Example of Stacks App——expression process
ba /
a/b+c*d
(a)
t1 +
a/b+c*d
t1=a/b
(b)
dct1
*+
a/b+c*d
(c)
t3
a/b+c*d
t3=t1+t2
(e)
t2t1 +
a/b+c*d
t2=c*d
(d)
91
Queues
FIFO: First in, First Out
Restricted form of list: Insert at one end, remove from the other.
Notation:
• Insert: Enqueue
• Delete: Dequeue
• First element: Front
• Last element: Rear
92
What is Queue?
• A series of data items, with the addition at the tail and deletion at the head
• Two pointers are required. One for the head of the list and another for the tail of the list
Head -1Tail - 1
93
Queue Model
Queue QDel Q(S)Add Q (x, Q)
x
Features of Queue:1. First-in-first–out (FIFO)2. Two pointers
94
Abstract queue class
template <class Elem> class Queue {public: virtual void clear() = 0; virtual bool enqueue(const Elem&) = 0; virtual bool dequeue(Elem&) = 0; virtual bool frontValue(Elem&) const = 0; virtual int length() const = 0;};
95
Queue Implementation (1)
96
Queue Implementation (2)
97
98