![Page 1: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/1.jpg)
27-Sep-19
1
Lecture No.04
Data Structures
Stacks
Stacks in real life: stack of books, stack of plates
Add new items at the top
Remove an item at the top
Stack data structure similar to real life: collection of elements
arranged in a linear order.
Can only access element at the top
![Page 2: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/2.jpg)
27-Sep-19
2
Stack Operations
Push(X) – insert X as the top element of the stack
Pop() – remove the top element of the stack and return it.
Top() – return the top element without removing it from the
stack.
Stack Operations
push(2)
top 2
push(5)
top
2
5
push(7)
top
2
5
7
push(1)
top
2
5
7
1
1 pop()
top
2
5
7
push(21)
top
2
5
7
21
21 pop()
top
2
5
7
7 pop()
2
5top
5 pop()
2top
![Page 3: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/3.jpg)
27-Sep-19
3
Stack Operation
The last element to go into the stack is the first to come out:
LIFO – Last In First Out.
What happens if we call pop() and there is no element?
Have IsEmpty() boolean function that returns true if stack is
empty, false otherwise.
Throw StackEmpty exception: advanced C++ concept.
Stack Implementation: Array
Worst case for insertion and deletion from an array when
insert and delete from the beginning: shift elements to the left.
Best case for insert and delete is at the end of the array – no
need to shift any elements.
Implement push() and pop() by inserting and deleting at the
end of an array.
![Page 4: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/4.jpg)
27-Sep-19
4
Stack using an Array
top
2
5
7
12 5 7 1
0 1 32 4
top = 3
Stack using an Array
In case of an array, it is possible that the array may “fill-up” if
we push enough elements.
Have a boolean function IsFull() which returns true is
stack (array) is full, false otherwise.
We would call this function before calling push(x).
![Page 5: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/5.jpg)
27-Sep-19
5
Stack Operations with Array
int pop()
{
return A[current--];
}
void push(int x)
{
A[++current] = x;
}
Stack Operations with Array
int top(){
return A[current];} int IsEmpty(){
return ( current == -1 );}int IsFull(){
return ( current == size-1);}
A quick examination shows that all five operations take constant time.
![Page 6: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/6.jpg)
27-Sep-19
6
Stack Using Linked List
We can avoid the size limitation of a stack implemented with
an array by using a linked list to hold the stack elements.
As with array, however, we need to decide where to insert
elements in the list and where to delete them so that push and
pop will run the fastest.
Stack Using Linked List
We can avoid the size limitation of a stack implemented with
an array by using a linked list to hold the stack elements.
As with array, however, we need to decide where to insert
elements in the list and where to delete them so that push and
pop will run the fastest.
![Page 7: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/7.jpg)
27-Sep-19
7
Stack Using Linked List
For a singly-linked list, insert at start or end takes constant time using the head and current pointers respectively.
Removing an element at the start is constant time but removal at the end required traversing the list to the node one before the last.
Make sense to place stack elements at the start of the list because insert and removal are constant time.
Stack Using Linked List
No need for the current pointer; head is enough.
top
2
5
7
11 7 5 2
head
![Page 8: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/8.jpg)
27-Sep-19
8
Stack Operation: List
int pop(){
int x = head->get();Node* p = head;head = head->getNext();delete p;return x;
}
top
2
5
71 7 5 2
head
Stack Operation: List
void push(int x){
Node* newNode = new Node();newNode->set(x);newNode->setNext(head);head = newNode;
}
top
2
5
7
9
7 5 2
head
push(9)
9
newNode
![Page 9: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/9.jpg)
27-Sep-19
9
Stack Operation: List
int top(){
return head->get();} int IsEmpty(){
return ( head == NULL );}
All four operations take constant time.
Stack: Array or List
Since both implementations support stack operations in constant time, any reason to choose one over the other?
Allocating and deallocating memory for list nodes does take more time than preallocated array.
List uses only as much memory as required by the nodes; array requires allocation ahead of time.
List pointers (head, next) require extra memory.
Array has an upper limit; List is limited by dynamic memory allocation.
![Page 10: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/10.jpg)
27-Sep-19
10
Use of Stack
Example of use: prefix, infix, postfix expressions.
Consider the expression A+B: we think of applying the
operator “+” to the operands A and B.
“+” is termed a binary operator: it takes two operands.
Writing the sum as A+B is called the infix form of the
expression.
Prefix, Infix, Postfix
Two other ways of writing the expression are
+ A B prefixA B + postfix
The prefixes “pre” and “post” refer to the position of the operator with respect to the two operands.
![Page 11: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/11.jpg)
27-Sep-19
11
Prefix, Infix, Postfix
Consider the infix expression
A + B * C
We “know” that multiplication is done before addition.
The expression is interpreted as
A + ( B * C )
Multiplication has precedence over addition.
Prefix, Infix, Postfix
Conversion to postfix
A + ( B * C ) infix form
![Page 12: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/12.jpg)
27-Sep-19
12
Prefix, Infix, Postfix
Conversion to postfix
A + ( B * C ) infix form
A + ( B C * ) convert multiplication
Prefix, Infix, Postfix
Conversion to postfix
A + ( B * C ) infix form
A + ( B C * ) convert multiplication
A ( B C * ) + convert addition
![Page 13: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/13.jpg)
27-Sep-19
13
Prefix, Infix, Postfix
Conversion to postfix
A + ( B * C ) infix form
A + ( B C * ) convert multiplication
A ( B C * ) + convert addition
A B C * + postfix form
Prefix, Infix, Postfix
Conversion to postfix
(A + B ) * C infix form
![Page 14: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/14.jpg)
27-Sep-19
14
Prefix, Infix, Postfix
Conversion to postfix
(A + B ) * C infix form
( A B + ) * C convert addition
Prefix, Infix, Postfix
Conversion to postfix
(A + B ) * C infix form
( A B + ) * C convert addition
( A B + ) C * convert multiplication
![Page 15: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/15.jpg)
27-Sep-19
15
Prefix, Infix, Postfix
Conversion to postfix
(A + B ) * C infix form
( A B + ) * C convert addition
( A B + ) C * convert multiplication
A B + C * postfix form
Precedence of Operators
The five binary operators are: addition, subtraction,
multiplication, division and exponentiation.
The order of precedence is (highest to lowest)
Exponentiation
Multiplication/division *, /
Addition/subtraction +, -
![Page 16: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/16.jpg)
27-Sep-19
16
Precedence of Operators
For operators of same precedence, the left-to-right rule
applies:
A+B+C means (A+B)+C.
For exponentiation, the right-to-left rule applies
A B C means A ( B C )
Infix to Postfix
Infix Postfix
A + B A B +
12 + 60 – 23 12 60 + 23 –
(A + B)*(C – D ) A B + C D – *
A B * C – D + E/F A B C*D – E F/+
![Page 17: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/17.jpg)
27-Sep-19
17
Infix to Postfix
Note that the postfix form an expression does not require parenthesis.
Consider ‘4+3*5’ and ‘(4+3)*5’. The parenthesis are not needed in the first
but they are necessary in the second.
The postfix forms are:
4+3*5 435*+
(4+3)*5 43+5*
Evaluating Postfix
Each operator in a postfix expression refers to the previous two operands.
Each time we read an operand, we push it on a stack.
When we reach an operator, we pop the two operands from the top of the
stack, apply the operator and push the result back on the stack.
![Page 18: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/18.jpg)
27-Sep-19
18
Evaluating Postfix
Stack s;
while( not end of input ) {
e = get next element of input
if( e is an operand )
s.push( e );
else {
op2 = s.pop();
op1 = s.pop();
value = result of applying operator ‘e’ to op1 and op2;
s.push( value );
}
}
finalresult = s.pop();
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
![Page 19: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/19.jpg)
27-Sep-19
19
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
![Page 20: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/20.jpg)
27-Sep-19
20
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
![Page 21: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/21.jpg)
27-Sep-19
21
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
![Page 22: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/22.jpg)
27-Sep-19
22
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
![Page 23: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/23.jpg)
27-Sep-19
23
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
![Page 24: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/24.jpg)
27-Sep-19
24
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
2 1 7 7 7,2
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
2 1 7 7 7,2
7 2 49 49
![Page 25: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/25.jpg)
27-Sep-19
25
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
2 1 7 7 7,2
7 2 49 49
3 7 2 49 49,3
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
2 1 7 7 7,2
7 2 49 49
3 7 2 49 49,3
+ 49 3 52 52
![Page 26: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/26.jpg)
27-Sep-19
26
Evaluating Postfix
Evaluate 6 2 3 + - 3 8 2 / + * 2 3 +
Input op1 op2 value stack
6 6
2 6,2
3 6,2,3
+ 2 3 5 6,5
- 6 5 1 1
3 6 5 1 1,3
8 6 5 1 1,3,8
2 6 5 1 1,3,8,2
/ 8 2 4 1,3,4
+ 3 4 7 1,7
* 1 7 7 7
2 1 7 7 7,2
7 2 49 49
3 7 2 49 49,3
+ 49 3 52 52
Converting Infix to Postfix
Consider the infix expressions ‘A+B*C’ and ‘ (A+B)*C’.
The postfix versions are ‘ABC*+’ and ‘AB+C*’.
The order of operands in postfix is the same as the infix.
In scanning from left to right, the operand ‘A’ can be inserted into postfix
expression.
![Page 27: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/27.jpg)
27-Sep-19
27
Converting Infix to Postfix
The ‘+’ cannot be inserted until its second operand has been scanned and
inserted.
The ‘+’ has to be stored away until its proper position is found.
When ‘B’ is seen, it is immediately inserted into the postfix expression.
Can the ‘+’ be inserted now? In the case of ‘A+B*C’ cannot because * has
precedence.
Converting Infix to Postfix
In case of ‘(A+B)*C’, the closing parenthesis indicates that ‘+’ must be
performed first.
Assume the existence of a function ‘prcd(op1,op2)’ where op1 and op2 are
two operators.
Prcd(op1,op2) returns TRUE if op1 has precedence over op2, FASLE
otherwise.
![Page 28: Lecture No.04 Data Structures€¦ · Stack Using Linked List We can avoid the size limitation of a stack implemented with an array by using a linked list to hold the stack elements](https://reader036.vdocuments.us/reader036/viewer/2022071109/5fe48cb5aea4ed3de11f629c/html5/thumbnails/28.jpg)
27-Sep-19
28
Converting Infix to Postfix
prcd(‘*’,’+’) is TRUE
prcd(‘+’,’+’) is TRUE
prcd(‘+’,’*’) is FALSE
Here is the algorithm that converts infix expression to its postfix form.
The infix expression is without parenthesis.