Data Structures and Algorithms C++ Implementation

Transcription

1 BK TP.HCM Ho Chi Minh City University of Technology Faculty of Computer Science and Engineering BK TP.HCM Data Structures and Algorithms C++ Implementation Huỳnh Tấn Đạt Home Page:

2 Basic stack operations Linked-list implementation Stack applications Array implementation Stacks Slide 2

3 Linear List Concepts General list: no restrictions on where can be inserted/deleted, and on which operations can be used on the list Restricted list: can be inserted/deleted and operations are performed only at the ends of the list Slide 3

4 Stack All insertions and deletions are restricted to one end called the top Last-In First-Out (LIFO) structure Slide 4

5 Basic Stack Operations Data Push Top Top Stack Stack Slide 5

6 Basic Stack Operations Overflow Data Top Stack Slide 6

7 Basic Stack Operations Pop Data Top Top Stack Stack Slide 7

8 Basic Stack Operations Underflow Top Stack Slide 8

9 Basic Stack Operations Stack Top Data Top Top Stack Stack Slide 9

10 Linked-List Implementation Top Stack structure top 5 Conceptual Physical Slide 10

11 Linked-List Implementation Stack structure count top stack count <integer> top <node pointer> end stack Stack node structure node <Type> <node pointer> end node Slide 11

12 Linked-List Implementation template <class ItemType> struct Node { ItemType ; Node<ItemType> *; }; template <class List_ItemType> class Stack { public: Stack(); ~Stack(); Slide 12

13 Linked-List Implementation void Push(List_ItemType In); int Pop(List_ItemType &Out); int GetStackTop(List_ItemType &Out); void Clear(); int IsEmpty(); int GetSize(); Stack<List_ItemType>* Clone(); void Print2Console(); private: Node<List_ItemType>* top; int count; }; Slide 13

14 Create Stack Before After?? count top 0 count top (no stack) (empty stack) Slide 14

15 Create Stack Algorithm createstack (ref stack <meta>) Initializes meta for a stack Pre stack is structure for meta Post meta initialized 1 stack.count = 0 2 stack.top = null 3 return End createstack Slide 15

16 Linked-List Implementation template <class List_ItemType> Stack<List_ItemType>::Stack(){ this->top = NULL; this->count = 0; } template <class List_ItemType> Stack<List_ItemType>::~Stack(){ this->clear(); } Slide 16

17 Push Stack Before After pnew red pnew red stack stack 2 blue 3 blue count top count top green green Slide 17

18 Push Stack Algorithm pushstack (ref stack <meta>, val <Type>) Inserts (pushes) one item into the stack Pre stack is a meta structure to a valid stack contains to be pushed into stack Post have been pushed in stack Return true if successful; false if memory overflow Slide 18

19 Push Stack 1 if (stack full) 1 success = false 2 else 1 allocate (pnew) 2 pnew -> = 3 pnew -> = stack.top 4 stack.top = pnew 5 stack.count = stack.count success = true 3 return success End pushstack Before pnew red stack 2 blue count top green Slide 19

20 Push Stack template <class List_ItemType> void Stack<List_ItemType>::Push (List_ItemType value){ Node<List_ItemType>* pnew = new Node<List_ItemType>(); pnew-> = value; pnew-> = top; this->top = pnew; this->count++; } Slide 20

21 Pop Stack Before After dltptr red dltptr recycled stack stack 3 blue 2 blue count top count top green green Slide 21

22 Pop Stack Algorithm popstack (ref stack <meta>, ref Out <Type>) Pops the item on the top of the stack and returns it to caller Pre stack is a meta structure to a valid stack Out is to receive the popped Post have been returned to caller Return true if successful; false if underflow Slide 22

23 Pop Stack 1 if (stack empty) 1 success = false Before 2 else 1 dltptr = stack.top 2 Out = stack.top -> dltptr stack red 3 stack.top = stack.top -> 4 stack.count = stack.count recycle (dltptr) 3 count top blue 6 success = true 3 return success End popstack green Slide 23

24 Pop Stack template <class List_ItemType> int Stack<List_ItemType>::Pop(List_ItemType &Out){ if (count == 0) return 0; Node<List_ItemType>* dltptr = this->top; Out = this->top->; this->top = this->top->; this->count--; delete dltptr; return 1; } Slide 24

25 Stack Top Algorithm stacktop (val stack <meta>, ref Out <Type>) Retrieves the from the top of the stack without changing the stack Pre Post stack is a meta structure to a valid stack Out is to receive top stack have been returned to caller Return true if successful; false Slide 25

26 Stack Top 1 if (stack empty) 1 success = false 2 else 1 Out = stack.top -> 2 success = true 3 return success End stacktop Slide 26

27 Stack Top template <class List_ItemType> int Stack<List_ItemType>::GetStackTop (List_ItemType &Out){ if (count == 0) return 0; Out = this->top->; return 1; } Slide 27

28 Destroy Stack Algorithm destroystack (ref stack <meta>) Releases all nodes back to memory Pre stack is a meta structure to a valid stack Post stack empty and all nodes recycled 1 if (stack not empty) 1 loop (stack.top not null) 1 temp = stack.top 2 stack.top = stack.top -> 3 recycle (temp) 2 stack.count = 0 3 return End destroystack Slide 28

29 Destroy Stack template <class List_ItemType> void Stack<List_ItemType>::Clear() { Node<List_ItemType>* temp; while (this->top!= NULL){ temp = this->top; this->top = this->top->; delete temp; } this->count = 0; } Slide 29

30 Stack Empty template <class List_ItemType> int Stack<List_ItemType>::IsEmpty() { return (count == 0); } template <class List_ItemType> int Stack<List_ItemType>::GetSize() { return count; } Slide 30

31 Print a stack template <class List_ItemType> void Stack<List_ItemType>::Print2Console() { } Node<List_ItemType>* p; p = this->top; while (p!= NULL){ } printf("%d\t", p->); p = p->; printf("\n"); Slide 31

32 Using Stacks int main(int argc, char* argv[]){ Stack<int> *mystack = new Stack<int>(); int val; mystack->push(7); mystack->push(9); mystack->push(10); mystack->push(8); mystack->print2console(); mystack->pop(val); mystack->print2console(); delete mystack; return 0; } Slide 32

33 Exercises template <class List_ItemType> Stack<List_ItemType>* Stack<List_ItemType>::Clone() { //... } Slide 33