Lists, Stacks, and Queues

Transcription

1 Data Structure Chapter 4 Lists, Stacks, and Queues Dr. Patrick Chan School of Computer Science and Engineering South China University of Technology Outline Lists (Ch 4.1) Introduction (4.1) Array-based List (4.1.1) Linked List (4.1.2) Comparison (4.1.3) Doubly Linked List (4.1.5) Stacks (Ch 4.3) Array-based Stack (Ch 4.3.1) Linked Stack (Ch 4.3.2) Queues (Ch 4.4) Array-based Queue (Ch 4.4.1) Linked Queue (Ch 4.4.2) Dictionary Example (Ch 4.2) 2

2 Lists: Introduction In real life, many data are finite and in order For example: Bank accounts Student records Application Example Simple Grading System Store the score for each student A List can be used Student I II III IV V Score Lists: Introduction A list of size n a 0 a 1 a 2 a n-1 Head element 3 rd element Tail Each element has a data type (atomic or structure) Empty list contains no elements The length is the number of elements stored The beginning of the list is called the The end of the list is called the 4

3 Lists: Introduction Sorted lists Elements positioned in ascending/descending order of value Unsorted lists No necessary relationship between element values and positions 5 Lists: Introduction Example: Simple Grading System 99 Student I II III IV V Score Head Tail 99 6

4 Lists: Introduction Functions: Get Value Insert / Modify / Delete Search 7 Lists: ADT class List { public: // reinitialize the list virtual void clear() = 0; // insert an item into the list before the current item virtual bool insert(const Elem&) = 0; // insert an item into the list at the end of the list virtual bool append(const Elem&) = 0; // remove the item at the current virtual bool remove(elem&) = 0; //set current to the beginning virtual void setstart() = 0; // set current to the last virtual void setend() = 0; 8

5 Lists: ADT // set current to the previous item virtual void prev() = 0; // set current to the next item virtual void next() = 0; // the size of the list before the current virtual int leftlength() const = 0; // the size of the list after and including the current virtual int rightlength() const = 0; // set current to the position indicated by the argument virtual bool setpos(int pos) = 0; // return the value of the current item in the argument virtual bool getvalue(elem&) const = 0; // print out the items in the list virtual void print() const = 0; ; 9 Lists Lists can be implemented by different methods (Physical Form) Array-Based List Linked List (pointer)

6 Lists: Array-Based List // Array-based list class AList : public List <Elem> { private: int ; // Maximum size of list int ; // Actual elem count int ; // Position of Elem* listarray; // Array holding list public: AList(int size=defaultlistsize) { = size; = = 0; listarray = new Elem[]; ~AList() { delete [] listarray; Alist grade(6); 11 Lists: Array-Based List Insert Function // Insert at front of right partition bool AList<Elem>::insert(const Elem& item) { if ( == ) return false; for(int i=; i>; i--) // Shift Elems up to make room listarray[i] = listarray[i-1]; listarray[] = item; ++; // Increment list size grade.ins ert( ); 12

7 Lists: Array-Based List Insert Function // Insert at front of right partition bool AList<Elem>::insert(const Elem& item) { if ( == ) return false; for(int i=; i>; i--) // Shift Elems up to make room listarray[i] = listarray[i-1]; listarray[] = item; ++; // Increment list size grade.ins ert( ); grade.ins ert( ); 13 Lists: Array-Based List Insert Function // Insert at front of right partition bool AList<Elem>::insert(const Elem& item) { if ( == ) return false; for(int i=; i>; i--) // Shift Elems up to make room listarray[i] = listarray[i-1]; listarray[] = item; ++; // Increment list size grade.ins ert( ); grade.ins ert( ); grade.ins ert( ); 14

8 Lists: Array-Based List Set Position Function bool AList<Elem>::setPos(int pos) { if ((pos >= 0) && (pos <= )) = pos; return (pos >= 0) && (pos <= ); grade.set Pos(2); 15 Lists: Array-Based List Get Value Function int AList<Elem>::righ tlen gth() const { return - ; int AList<Elem>::left Leng th() const { return ; bool ALis t<elem>::getvalue(elem& it) const { if (rightlength() == 0) return false; else { it = listarray[]; mark = grade.getvalue(mark); 16

9 Lists: Array-Based List Append Function bool AList<Elem>::append(const Elem& item) { if ( == ) return false; listarray[++] = item; grade.app end( ); 17 Lists: Array-Based List Append Function AList<Elem>::append(const Elem& item) { if ( == ) return false; listarray[++] = item; grade.app end( ); grade.app end( ); 18

10 Lists: Array-Based List Remove Function // Remove and return first Elem in right partition bool AList<Elem>::remove(Elem& it) { if (rightlength() == 0) return false; it = listarray[]; // Copy Elem for(int i=; i<-1; i++) listarray[i] = listarray[i+1]; // Shift them down --; // Decrement size grade.rem ove( mark); mark = 19 Lists: Array-Based List Other Functions void AList<Elem>::setStart() { = 0; void AList<Elem>:: setend() { = ; void AList<Elem>:: prev() { if (!= 0) --; void AList<Elem>:: next() { if ( <= -1) ++; grade.setstart(); 20

11 Lists: Array-Based List Other Functions void AList<Elem>::setStart() { = 0; void AList<Elem>:: setend() { = ; void AList<Elem>:: prev() { if (!= 0) --; void AList<Elem>:: next() { if ( <= -1) ++; grade.setstart(); grade.setend(); 21 Lists: Array-Based List Other Functions void AList<Elem>::setStart() { = 0; void AList<Elem>:: setend() { = ; void AList<Elem>:: prev() { if (!= 0) --; void AList<Elem>:: next() { if ( <= -1) ++; grade.setstart(); grade.setend(); grade.prev(); 22

12 Lists: Array-Based List Other Functions void AList<Elem>::setStart() { = 0; void AList<Elem>:: setend() { = ; void AList<Elem>:: prev() { if (!= 0) --; void AList<Elem>:: next() { if ( <= -1) ++; grade.setstart(); grade.setend(); grade.prev(); grade.next(); 23 Lists: Array-Based List Print Function void AList<Elem>:: print() const { int temp = 0; cout << < ; while (temp < ) cout << listarray[temp++] << ; cout << ; while (temp < ) cout << listarray[temp++] << ; cout << >\n ; grade.print(); < > 24

13 Lists: Array-Based List Print Function void AList<Elem>:: print() const { int temp = 0; cout << < ; while (temp < ) cout << listarray[temp++] << ; cout << ; while (temp < ) cout << listarray[temp++] << ; cout << >\n ; grade.print(); < > 25 Small Exercise AList height(4); height.append(163); height.append(1); height.setpos(1); height.insert(180); height.prev(); height.remove(temp);

14 Small Exercise We would like to implement to a sorted list (ascending order) by modifying the current list data type Q1: List all functions the list data type has. Which functions should be modified or deleted in sorted list data type? clear insert append remove setstart setend Prev Next setpos leftlength rightlenght getvalue print 27 Small Exercise Q2: Rewrite the insert function for sorted list data type. // Array-based list class AList : public List<Elem> { priva te: int ; // Maximum size of list int ; // Actual elem count int ; // Position of Elem* l ista rray; // Array holding list publi c: ALi st(i nt size=defaultlistsize) { = size; = = 0; listarray = new Elem[]; ~AList() { delete [] listarray; bool ALis t<elem>::insert( cons t Elem& item) {. 28

15 Small Exercise bool AList<Elem>::insert(const Elem& item) { if ( == ) return false; suitpos = 0; while ((item>listarray[suitpos])&&(suitpos < )) suitpos++; for(int i=; i>; suitpos; i--) i--) // Shift Elems up to make room listarray[i] = listarray[i-1]; listarray[] suitpos] = = item; item; ++; // Increment list size slist.insert(34); 29 Lists: Array-Based List Pros and Cons Advantages: No over if all array positions are full Over: Amount of space necessary to maintain the data structure Disadvantages: Array must be allocated in advance Too many: Waste Memory Linked List can solve this problem 30

16 Lists: Linked List A node in a linked list is defined as: // Linked list node class Link { public: Elem element; // Value for this node Link *next; // Pointer to next node Link(const Elem& elemval, Link* nextval=){ element = elemval; next = nextval; Link(Link* nextval=){ next = nextval; ; Link temp; Link temp(); element next 31 Lists: Linked List // Linked list implementation class LList : public List<Elem> { priva te: Link<Elem>* ; //Point to list er Link<Elem>* ; //Pointer to last Elem Link<Elem>* ; //Last element on left int lef tcnt; //Size of left int rightcnt; //Size of right void in it() { //Initia lization routine = = = new Link<Elem>; leftcnt = rightcnt = 0; void removeall() { //Remove link nodes to free store while(hea d!= ) { = ; = ->next; delete ; LList Grade; Grade.init(); leftcnt = 0 rightcnt = 0 32

17 Lists: Linked List Link(const Elem& elemval, Link* nextval=){ element = elemval; next = nextval; Insert Function Link<Elem>* temp = new Link<Elem>(item, ->next); // Insert at front of right partition ->next = temp; bool LList<Elem>::insert(const Elem& item) { ->next = new Link<Elem>(item, ->next); if ( == ) = ->next; rightcnt++; grade.ins ert( ); leftcnt = 0 rightcnt = Lists: Linked List Insert Function // Insert at front of right partition bool LList<Elem>::insert(const Elem& item) { ->next = new Link<Elem>(item, ->next); if ( == ) = ->next; rightcnt++; grade.ins ert( ); grade.ins ert( ); Link<Elem>* temp = new Link<Elem>(item, ->next); ->next = temp; leftcnt = 0 rightcnt = 12 34

18 Lists: Linked List Insert Function // Insert at front of right partition bool LList<Elem>::insert(const Elem& item) { ->next = new Link<Elem>(item, ->next); if ( == ) = ->next; rightcnt++; grade.ins ert( ); grade.ins ert( ); grade.ins ert( ); leftcnt = 0 rightcnt = Lists: Linked List Set Position Function // Set the size of left partition to pos bool LList<Elem>::setPos(int pos) { if ((pos < 0) (pos > rightcnt+leftcnt)) return false; = ; for(int i=0; i<pos; i++) = ->next; rightcnt = rightcnt+leftcnt-pos; leftcnt = pos; grade.set Pos(3); leftcnt = 03 rightcnt = 30 36

19 Lists: Linked List Set Position Function // Set the size of left partition to pos bool LList<Elem>::setPos(int pos) { if ((pos < 0) (pos > rightcnt+leftcnt)) return false; = ; for(int i=0; i<pos; i++) = ->next; rightcnt = rightcnt+leftcnt-pos; leftcnt = pos; grade.set Pos(3); grade.set Pos(2); leftcnt = 32 rightcnt = Lists: Linked List Get Value Function int LList<Elem>:: rightlength() const { return rightcnt; int LList<Elem>:: leftlength() const { return leftcnt; bool LList<Elem>:: getvalue(elem& it) const { if(rightlength() == 0) return false; it = ->next->element; grade.getvalue(mark); mark = leftcnt = 2 rightcnt = 1 38

20 Lists: Linked List Append Function // Append Elem to end of the list bool LList<Elem>::append(const Elem& item) { = ->next = new Link<Elem>(item, ); rightcnt++; grade.app end( ); leftcnt = 2 rightcnt = Lists: Linked List Append Function // Append Elem to end of the list bool LList<Elem>::append(const Elem& item) { = ->next = new Link<Elem>(item, ); rightcnt++; grade.app end( ); grade.app end( ); leftcnt = 2 rightcnt = 23 40

21 Lists: Linked List Remove Function // Remove and return first Elem in right partition bool LList<Elem>::remove(Elem& it) { if (->next == ) return false; it = ->next->element; // Remember val Link<Elem>* ltemp = ->next; // Remember link node ->next = ltemp->next; // Remove if ( == ltemp) // Reset mark = = ; grade.rem ove( mark); delete ltemp; // Reclaim space rightcnt--; leftcnt = 2 rightcnt = Lists: Linked List Set Start and Set End Functions void LList<Elem>:: setstart() { = ; rightcnt += leftcnt; leftcnt = 0; grade.setstart(); void LList<Elem>:: setend() { = ; leftcnt += rightcnt ; rightcnt = 0; leftcnt = 20 rightcnt = 24 42

22 Lists: Linked List Set Start and Set End Functions void LList<Elem>:: setstart() { = ; rightcnt += leftcnt; leftcnt = 0; void LList<Elem>:: setend() { = ; leftcnt += rightcnt ; rightcnt = 0; grade.setstart(); grade.setend(); leftcnt = 04 rightcnt = Lists: Linked List Previous Functions void LList<Elem>:: prev() { Link<Elem>* temp = ; if ( == ) return; // No prev Elem while (temp->next!=) temp=temp->next; = temp; leftcnt--; grade.prev(); rightcnt++; leftcnt = 43 rightcnt = 01 44

23 Lists: Linked List Next Functions void LList<Elem>:: next() { if ( == ) return; // No next Elem = ->next; leftcnt++; rightcnt--; grade.next(); leftcnt = 34 rightcnt = 45 Lists: Linked List Print Functions grade.print(); < > void LList<Elem>:: print() const { Link<Elem>* temp = ; cout << < ; while (temp!= ) { cout << temp->next->element << ; temp = temp->next; cout << ; while (temp->next!= ) { cout << temp->next->element << ; temp = temp->next; cout << >\n ; leftcnt = 4 rightcnt = 0 46

24 Lists: Linked List Print Functions grade.print(); < > void LList<Elem>:: print() const { Link<Elem>* temp = ; cout << < ; while (temp!= ) { cout << temp->next->element << ; temp = temp->next; cout << ; while (temp->next!= ) { cout << temp->next->element << ; temp = temp->next; cout << >\n ; leftcnt = 2 rightcnt = 2 47 Small Exercise LList height; height.append(163); height.append(1); height.setpos(1); height.insert(180); height.prev(); height.remove(temp);

25 Small Exercise Q1: Write a swap function to swap two adjacent elements (->next, ->next->next) of a linked list by adjusting only the pointers 49 Small Exercise 50

26 Small Exercise bool LList<Elem>:: swap() { if ( == ) return false; if (->next == ) return false; Link<Elem>* temp = ->next; ->next = temp->next; temp->next = ->next->next; ->next->next = temp; if (->next == ) = ->next; 51 Small Exercise Q2: Write a findndel function which deletes all the occurrence of a given ITEM in a linked list (Do no use remove() function) 52

27 Small Exercise bool LList<Elem>:: findndel(elem value) { if ( == ) return false; Link<Elem>* temp; Link<Elem>* ptr = ; bool beforefence = true; while (ptr <> ) { // check if the ptr passes by if (ptr == ->next) beforefence = false; if (ptr->next->element == value) { // check the list if ( == ptr->next) = ptr; if ( == ptr->next) = ptr; temp = ptr->next; ptr->next = ptr->next->next; delete temp; if (beforefence) leftcnt--; else rightcnt--; else ptr = ptr->next; 53 Lists: Comparison Array-Based Lists Insertion and deletion are Θ(n) Prev and direct access are Θ(1) Array must be allocated in advance No over 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 over 54

28 Lists: Comparison Memory Space Array-Based Lists Linked Lists DE n(e + P) E: P: D: n: Space for data value Space for pointer Number of elements in array Number of current elements 55 Lists Singly Linked List Allows for direct access from a list node only to the next node in the list It is not convenient to access the previous element (Θ(n)) Doubly Linked List Allow convenient access the next node and also the previous node (Θ(1)) 56

29 Lists: Doubly Linked List // Doubly-linked list link node 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=, Link* nextp=) { element=e; prev=prevp; next=nextp; Link(Link* prevp=, Link* nextp=) { prev=prevp; next=nextp; ; element Link temp; prev next 57 Lists: Doubly Linked List Insert Function // Insert at front of right partition bool LList<Elem>::insert(const Elem& item) { ->next = new Link<Elem>(item,, ->next); if (->next->next!= ) ->next->next->prev = ->next; if ( == ) // Appending new Elem = ->next; // Set rightcnt++; // Added to right grade.ins ert( ); 58

30 Lists: Doubly Linked List Insert Function // Insert at front of right partition bool LList<Elem>::insert(const Elem& item) { ->next = new Link<Elem>(item,, ->next); if (->next->next!= ) ->next->next->prev = ->next; if ( == ) // Appending new Elem = ->next; // Set rightcnt++; // Added to right grade.ins ert( ); grade.ins ert( ); 59 Lists: Doubly Linked List Remove Function // Remove, return first Elem in right part bool LList<Elem>::remove(Elem& it) { if (->next == ) return false; it = ->next->element; Link<Elem>* ltemp = ->next; if (ltemp->next!= ) ltemp->next->prev = ; else = ; // Reset ->next = ltemp->next; // Remove delete ltemp; // Reclaim space rightcnt--; // Removed from right grade.rem ove( mark); mark = 60

31 Lists: Doubly Linked List Remove Function void LList<Elem>::prev() { // no prev Elem if (!= ) { = ->prev; leftcnt--; rightcnt++; Doubly Linked List grade.prev(); void LList<Elem>::prev() { Link<Elem>* temp = ; // No prev Elem if ( == ) return; while (temp->next!=) temp=temp->next; = temp; leftcnt--; rightcnt++; Singly Linked List Stacks Restricted form of a List Insert only at the front Remove from the front TOP First-In-Last-Out (FILO) Notation Insert: PUSH Remove: POP The accessible element is called TOP 62

32 Stacks class AStac k: public St ack<elem> { priva te: int max Size; // Maximum size of stack int top; // Index for top element Elem *l ista rray; // Array holding stack elements publi c: AStack(int size =De faultlistsiz e) // Constructor { = size; top = 0; listarray = new Elem[size]; ~AStack() { delete [] listarray; // Destructor ; class LStac k: public St ack<elem> { priva te: Link<Elem>* top; // Pointer to first element int size; // Number o f elements publi c: LStack(int sz =DefaultListSize) { top = ; size = 0; ~LStack() { clear(); // Destructor Array-based Stack top=0 top Linked Stack 63 Stacks: Push Function Array-based Stack bool AStac k<elem>::push(const Elem& it) { // Put it on stack if (top == ) return false; // Stack is full else { listarray[top++] = it; bool LStack<Elem>:: push(const Elem& it) { // Put it on stack top = new Link<Elem>(it, top); size++; Linked Stack 42 top top= stack.push(); stack.push(42); 64

33 Stacks: Pop Function bool AStack<Elem>:: bool pop(elem& it) {// Pop top element if (top == 0) return false; else { it = listarray[--top]; Array-based Stack Linked Stack bool LStack<Elem>:: bool pop(elem& it) { // Remove it from stack if (size == 0) return false; it = top->element; Link<Elem>* ltemp = t op->next; delete top; top = ltemp; size--; 42 top= 12 value=42 stack.pop(val ue); value=42 top 65 Queues Restricted form of a list Insert at one end Remove from the other end First-In-First-Out (FIFO) Notation Insert: Enqueue Delete: Dequeue First Element: FRONT Last Element: REAR REAR Dequeue Enqueue FRONT 66

34 Queues class AQueu e: public Qu eue<elem> { priva te: int size; // Maximum size of queue int front; // Index of front element int rear; // Index of rear element Elem *l ista rray; // Array holding queue elements publi c: AQueue(int sz =DefaultListSize) { // Constructor // Make list array one position larger for empty slot size = sz+1; rear = 0; front = 1; listarray = new Elem[size]; Array-based Queue ~AQueue() { delete [] listarray; // Destructor rear front 67 Queues class LQueu e: public Qu eue<elem> { priva te: Link<Elem>* front; // Pointer to front queue node Link<Elem>* rear; // Pointer to rear queue node int size; // Number of elements in queue publi c: LQueue(int sz =DefaultListSize) // Constructor { front = ; rear = ; size = 0; Linked Queue ~LQueue() { clear(); // Destructor rear front 68

35 Queues: Enqueue Function Array-based Queue bool AQue ue <Elem>::enqueue(c onst Elem& it) { // Put element on rear if (rear == size) return false; // Full rear = rear+1; // increment listarray[rear] = it; Linked Queue bool LQue ue <Elem>::enqueue(c onst Elem& it) { // Put element on rear if (rear == ) // Empty queue front = rear = new Link<Elem>(it, ); else { // Append new node rear->next = new Link<Elem>(it, ); rear = rear->next; queue.enqueue(); size++; queue.enqueue(42); rear 42 front 42 front rear 69 Queues: Dequeue Function bool AQue ue <Elem>::dequeue(E lem& it) { // Take element out if (length() == 0) return false; // Empty it = listarray[front]; front = front+1; // Circular increment bool LQue ue <Elem>::dequeue(E lem& it) { // Remove element from front if (size == 0) return false; // Empty it = front->element; // Store dequeued valu e Link<Elem>* ltemp = front; // Hold dequeued link front = front->next; // Advance front delet e lt emp; // Delete link if (front == ) rear = ; // Dequeued last element size --; // Return element value queue.dequeue(value); rear Array-based Queue rear Linked Queue front value = value = front 70

36 Queues A problem of Array-based Queue front rear After some operations rear After some operations front rear The queue is FULL although some memory spaces are available! front 71 Queues Solution: rear front size-1 Circular Queue Pretend the array is circular size - 1 is defined to immediately precede position 0 0 rear size front

37 Queues: Circular Queue bool LQueue <Elem>:: enqueue(const Elem& it){ if (((rear+2) % size) == front) return false; // Full rear = (rear+1) % size; // Circular increment listarray[rear] = it; bool LQueue <Elem>:: dequeue(elem& it) { if (length() == 0) return false; // Empty it = listarray[front]; front = (front+1) % size; // Circular increment