A linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list.

Size: px

Start display at page:

Download "A linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list."

Annabelle Mosley
6 years ago
Views:

2 A linear-list Data Structure where - addition of elements to and - removal of elements from are restricted to the first element of the list. the first element of the list

3 a new element to (the Top of) the stack. an element from (the Top of) the stack (and return it).

4 the stack (of ints) starts push(1) push(2) push(3) pop() - returns 3 pop() - returns 2 pop() - returns 1

5 ast n, irst ut Describes the order that elements are added to and removed from a Stack.

6 - Automatic Memory allocation in a computer program. - Editing: allows Undo/Redo - Web Browsing: allows Back/Forward - Compilers: used for syntax checking

7 A linear-list Data structure where - addition of elements is restricted to the end (rear) of the list. - removal of elements is restricted to the beginning (front) of the list. first element in the queue last element in the queue

8 a new element to (the Rear of) the Queue. an element from (the Front of) the Queue (and return it).

9 the Queue (of ints) starts enq(1) enq(2) enq(3) deq() - returns 1 deq() - returns 2 deq() - returns 3

10 irst n, irst ut Describes the order that elements are added to and removed from a Queue.

11 - Web Server: processing service requests - Cell Tower: processing data packets from cell phones. - OS Scheduling: sharing of a single CPU by multiple "running" programs. - Fast Food Drive-Through order processing.

12 Stacks and Queues may be implemented in a program using any Linear Data structure, including: - Arrays - Vectors - Linked Lists

13 For a Linked List (dynamic) implementation, the node class would be: class node { friend class stack; // or queue private: node * next = NULL; string data = ""; }; The node may contain any number of data members needed. Here, there is just one, a string.

14 After allocating and populating a new node (pointed to by n), we make the new node the new top. Left: general case Right: empty stack case blue: before Pushing red: after Pushing

15 void stack::push(string newdata) { node * n = new node; // allocate n->data = newdata; // populate n->next = top; // connect new node // to old top. top = n; // new node is the } // new top.

16 Remove the top node and deallocate it. Return the data from the popped node.

17 string stack::pop() { string olddata = top->data; //save node * n = top; // pnt to old top top = top->next; // pnt top to next delete n; // dealloc old top return olddata; }

18 For a Linked List, the Q class would be: class queue { public: void enq(string newdata); string deq(); private: node * front = NULL; node * rear = NULL; };

19 There are 3 cases we should check for enqueue and dequeue: 1. empty queue 2. queue of one node 3. queue of two or more nodes The diagrams in the following slides show the new node already allocated and populated.

20 Empty When front and rear are NULL, the queue is empty. Just make both front and rear point to the new node.

21 1 node in queue When front and rear both point to the same node, there is only one node in the queue. No change to front, just attach the new node after the current rear and make it the new rear.

22 2 or more nodes When front and rear point to different nodes, there are 2 or more nodes in the queue. No change to front, just attach the new node after the current rear and make it the new rear. [same action as for queue of 1 node, so these two cases can be combined for enqueue]

23 void queue::enq(string newdata) { node * n = new node; // allocate n->data = newdata; // populate if (front == NULL) { // empty Q front = n; rear = n; } else { // Q of 1 or more rear->next = n; rear = n; }

24 empty queue When front and rear are NULL, the queue is empty. There is nothing to remove and return, so just return some data that means "none", such as Empty String

25 queue of one node Save a copy of the data in the front node. Deallocate the one node. Set both front and rear to NULL to make it empty. Return the data.

26 2 or more nodes Save a copy of the data in the front node. Make front point to the next node. Deallocate the old front. Return the data.

27 string queue::deq() { if (front==null) return ""; // empty Q case node * n = front; // ptr to old front string olddata = n->data; // save for return if (front==rear) { // Q of 1 node front = NULL; // make the queue rear = NULL; // empty. } else // 2 or more nodes front = front->next; // move front to next delete n; // dealloc old front return olddata; }

28 We want to write methods that are and The four methods written above do: - allocate, populate and insert [push and enq] OR - save return data, remove, deallocate, return data. [pop and deq]

29 In many cases, we need to Push/Enqueue an already allocated and populated node; and we may need to use a Popped/Dequeued node elsewhere instead of destroying it.

30 So, it would have been better to split these into at least two methods: - one that only manipulates pointers - another that allocates/deallocates and populates (or saves/returns data), that invokes the first method.

31 void stack::push(node * n) { // ptr to node already alloc/pop n->next = top; top = n; } void stack::push(string newdata) { node * n = new node; // allocate n->data = newdata; // populate push(n); // put on stack } Now programmers have a choice: Just give data, and have it allocated/populated/pushed; OR, I already have a node with data populated...just push it.

32 Term Stack Top Push Pop LIFO Queue Front Rear Enqueue Dequeue FIFO Definition A linear-list Data structure where addition of elements to and removal of elements from (the list) are restricted to the first element of the list. First element of a Stack. Stack Operation: add an element to the top. Stack Operation: remove an element from the top. Order of adding/removing items to/from a Stack. Last In, First Out A linear-list Data structure where addition of elements is restricted to the end of the list, and removal of elements is restricted to the beginning of the list. First element of a queue, the next to be removed. Last element of a queue, the last to be added. Queue Operation: add an element to the rear. Queue Operation: remove an element from the front. Order of adding/removing items to/from a Queue. First In, First Out

.:: UNIT 4 ::. STACK AND QUEUE

.:: UNIT 4 ::. STACK AND QUEUE 4.1 A stack is a data structure that supports: Push(x) Insert x to the top element in stack Pop Remove the top item from stack A stack is collection of data item arrange