Stacks: Last In First Out Programming, Data Structures and Algorithms English Malayalam

Stacks: Last In First OutYouTube↗ IA↗(long shot)
People & Blogs 1.8K views 5 likes 0 dislikes 30 Jan 2018

Programming, Data Structures and Algorithms 451 subscribers N/A YouTube↗

Good morning class, in the last class we did the ADT call list.

ADT ലിസ്റ്റ് (list) എന്താണ്? ക്രമീകരിക്കാത്ത ഇനങ്ങളുടെ ശ്രേണിയാണ് ലിസ്റ്റ് (list), തുടർന്ന് ലിസ്റ്റിലെ (list) ഒരുപാട് പ്രവർത്തനങ്ങൾ ഞങ്ങൾ നിർവചിച്ചു. ലിസ്റ്റ് (list) നടപ്പിലാക്കുന്നതിനെക്കുറിച്ചും

ഞങ്ങൾ സംസാരിച്ചു. രണ്ട് വ്യത്യസ്ത

And to just recap what is the ADT list? List is the sequence of items unordered items for

നടപ്പാക്കലുകളെക്കുറിച്ച് ഞങ്ങൾ സംസാരിച്ചുവെങ്കിലും ലിങ്ക്ഡ് ലിസ്റ്റ് (linked list) നടപ്പിലാക്കൽ

that matter and then we defined a whole lot of operations on list. We also looked at the

വിശദമായി ഞാൻ കാണിച്ചു. അറേയും (array) ലിങ്ക്ഡ്

implementation of list, what we talk about, we talked about two different implementations

ലിസ്റ്റും (linked list) ലിസ്റ്റിന്റെ (list)

although I showed you in detail link list implementation. Both the array and the link list and I showed you a link list implementation of the list. I encourage you to do the array

ഒരു ലിങ്ക്ഡ് ലിസ്റ്റ് (linked list) നടപ്പാക്കലും ഞാൻ കാണിച്ചു. ലിസ്റ്റിന്റെ (list) അറേ നടപ്പിലാക്കൽ ചെയ്യാൻ ഞാൻ നിങ്ങളെ പ്രോത്സാഹിപ്പിക്കുന്നു.

implementation of the list. Now, I just have some problems over here, I would like you

ഇപ്പോൾ, എനിക്ക് ഇവിടെ ചില പ്രശ്‌നങ്ങളുണ്ട്,

to work on storing sets I gave you an example of storing sets using list. And basically we want to perform operations on set union, intersection and set A minus

സെറ്റുകൾ (set) സംഭരിക്കുന്നതിന് നിങ്ങൾ പ്രവർത്തിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, ലിസ്റ്റ് (list) ഉപയോഗിച്ച് സെറ്റുകൾ (set) സംഭരിക്കുന്നതിന് ഞാൻ നിങ്ങൾക്ക് ഒരു

set B. I also want you to look at another application of list is what we call infinite precision

ഉദാഹരണം നൽകി. അടിസ്ഥാനപരമായി സെറ്റ് യൂണിയൻ (set

arithmetic. That is if you want to do let us say you have a 64 bit machine and you want higher precision in 64 bit, then you can use the list as a structure to perform arithmetic

union), ഇന്റർസെക്ഷൻ (intersection), എ മൈനസ് സെറ്റ് ബി (set A - set B) എന്നീ പ്രവർത്തനങ്ങൾ നടത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. ലിസ്റ്റിന്റെ (list) മറ്റൊരു ആപ്ലിക്കേഷൻ

on it. So, basically what we do is, what we are talking about is in the list here you are a 1, a 2,

(application) നിങ്ങൾ നോക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു, ഇതിനെ ഇൻഫൈനൈറ്റ് പ്രിസിഷൻ അരിത്‌മെറ്റിക്

a 3 up to a n corresponds to different parts of the given number and then you define operations to perform arithmetic operations on this number represented as a list of element. What I mean

(infinite precision arithmetic) എന്ന് വിളിക്കുന്നു. നിങ്ങൾ‌ക്ക് 64 ബിറ്റ് (bit) മെഷീനുണ്ടെന്നും (machine) 64 ബിറ്റിൽ‌ (bit) കൂടുതൽ‌ കൃത്യത വേണമെന്നും പറയാൻ‌ നിങ്ങൾ‌ താൽ‌പ്പര്യപ്പെടുന്നെങ്കിൽ‌,

by that is, the numbers represented in parts in terms of a 1, a 2,..., a n and you want

നിങ്ങൾ‌ക്ക് ലിസ്റ്റ് (list) ഉപയോഗിക്കാൻ കഴിയും. അടിസ്ഥാനപരമായി ഞങ്ങൾ ചെയ്യുന്നത്,

to perform arithmetic operations on them. So, I would like you to try these problems.

ഇവിടെയുള്ള ലിസ്റ്റിൽ (list) നിങ്ങൾ a1, a2, a3…..,an

I also have a few assignment problems we talked about this a little in the last class. But,

എന്നിവ തന്നിരിക്കുന്ന സംഖ്യയുടെ വിവിധ

I would like you to write a function to remove duplicates in a given list using only list

ഭാഗങ്ങളാണ്, തുടർന്ന് ഗണിത പ്രവർത്തനങ്ങൾ

operations. And basically a function which takes a list and returns the purged list and

നടത്താനുള്ള പ്രവർത്തനങ്ങൾ നിങ്ങൾ നിർവചിക്കുന്നു മൂലകത്തിന്റെ ലിസ്റ്റായി (list) നമ്പർ പ്രതിനിധീകരിക്കുന്നു.

I also want you to convert a given unordered list into an ordered list, again it should be done in place. So, I would like you to do these two problems on this.

ഞാൻ ഇത് അർത്ഥമാക്കുന്നത്, a1, a2, ..., an എന്നിവയുടെ

Now, next what we going to talk about is the different type of ADT called a stack. What are the stack now? Stack is also a list, but it has a fundamental difference, it is the

അടിസ്ഥാനത്തിൽ ഗണിത പ്രവർത്തനങ്ങൾ നടത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. കഴിഞ്ഞ ക്ലാസ്സിൽ സംസാരിച്ച ചില അസൈൻമെന്റ് പ്രശ്നങ്ങളും എനിക്കുണ്ട്. പക്ഷേ, ലിസ്റ്റ്

(list) പ്രവർത്തനങ്ങൾ മാത്രം ഉപയോഗിച്ച് തന്നിരിക്കുന്ന ലിസ്റ്റിലെ (list) തനിപ്പകർപ്പുകൾ

special type of list ADT and the difference in the stack is that it operates on principles

നീക്കംചെയ്യുന്നതിന് നിങ്ങൾ ഒരു ഫംഗ്ഷൻ (function) എഴുതാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. അടിസ്ഥാനപരമായി

of what is called last in, first out. What is the meaning of this, that is the last element

ഒരു ലിസ്റ്റ് (list) എടുത്ത് ശുദ്ധീകരിച്ച ലിസ്റ്റ് (list) മടക്കിനൽകുന്ന ഒരു ഫംഗ്ഷൻ (function), തന്നിരിക്കുന്ന

which enters into the list is removed first, this is called a stack. Now, let me give you some example when you putting books on your table, then you put the top most, the most recent book will be the top most book and then when you remove for example, if you want to remove this particular book, you remove the top two books before

ക്രമീകരിക്കാത്ത ലിസ്റ്റ് (list) ഒരു ഓർഡർ (order) ചെയ്ത ലിസ്റ്റിലേക്ക് (list) പരിവർത്തനം ചെയ്യണമെന്നും ഞാൻ ആഗ്രഹിക്കുന്നു, അത് ഇൻ പ്ലെയ്സ് (in place) ആയി തന്നെ ചെയ്യണം. അതിനാൽ, ഈ രണ്ട് പ്രശ്നങ്ങളും

you can remove this book. And other example let us talk about plates that are stacked in a cupboard, see put your

നിങ്ങൾ ഇത് ചെയ്യാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഇപ്പോൾ, അടുത്തതായി നമ്മൾ സംസാരിക്കാൻ

plates over here and like this and you remove the top most plate. The most recent plate

പോകുന്നത് സ്റ്റാക്ക് (stack) എന്ന് വിളിക്കുന്ന വ്യത്യസ്ത തരം ADT ആണ്. സ്റ്റാക്ക്

is what is first removed, if you want to remove the third plate from the top plate, you remove

(stack) ഒരു ലിസ്റ്റ് (list) കൂടിയാണ്, പക്ഷേ

the first two before you can remove the third plate. So, stack has lot of nice applications

ഇതിന് അടിസ്ഥാനപരമായ വ്യത്യാസമുണ്ട്, ഇത് പ്രത്യേക തരം ലിസ്റ്റ് എ‌ഡി‌ടിയാണ്

and we will talk about a specific application of a stack. The operations that are supported by the stack are you can push, you can pop and you can find what is the top most element in the stack, can also check whether the given stack is

(list ADT), ഒപ്പം സ്റ്റാക്കിലെ (stack) വ്യത്യാസം അത് ലാസ്റ്റ് ഇൻ ഫസ്റ്റ് ഔട്ട് (last in first out) എന്ന്

empty or not. So, these are the four operations that are normally supported by the stack and

വിളിക്കപ്പെടുന്ന തത്വങ്ങളിൽ പ്രവർത്തിക്കുന്നു എന്നതാണ്. ഇതിന്റെ അർത്ഥമെന്താണ്, ലിസ്റ്റിലേക്ക്

now since stack is a special type of list, I want to show you one example here where,

(list) പ്രവേശിക്കുന്ന അവസാന ഘടകം ആദ്യം നീക്കംചെയ്യുന്നു, ഇതിനെ സ്റ്റാക്ക്

since you know now the way we looked at it is, I have already implemented the list ADT

(stack) എന്ന് വിളിക്കുന്നു. ഞാൻ‌ ചില ഉദാഹരണങ്ങൾ

and since I have already implemented the list ADT, I would like to use that list itself to represent a stack. So, how do I go about doing that, the way

നൽ‌കാം. നിങ്ങളുടെ മേശയിൽ‌ പുസ്‌തകങ്ങൾ വെക്കുമ്പോൾ ഒന്നിന് മുകളിൽ ഒന്നായിട്ടാണ് അടുക്കുന്നത്. ഏറ്റവും മുകളിൽ ഉള്ള പുസ്തകം ആണ് ആദ്യം എടുക്കാൻ പറ്റുന്നത്.

I would do that is since the list ADT has been you know you already debugged it, you

മറ്റൊരു ഉദാഹരണം ഒരു അലമാരയിൽ അടുക്കിയിരിക്കുന്ന പ്ലേറ്റുകളെക്കുറിച്ച് സംസാരിക്കാം, നിങ്ങളുടെ

have tested it and so on and so forth. So, what we could do is we could use the list

പ്ലേറ്റുകൾ ഇവിടെ വയ്ക്കുക, ഇതുപോലെ

ADT itself as a stack. So, how would I do that then, then what I will do is I will restrict

കാണുക, ഏറ്റവും മുകളിൽ ഉള്ള പ്ലേറ്റ് നീക്കംചെയ്യുക.

my operations. So, what I will says that the push operation, so with in my I can write an ADT stack here

മുകളിലുള്ള പ്ലേറ്റിൽ നിന്ന് മൂന്നാമത്തെ പ്ലേറ്റ് നീക്കംചെയ്യണമെങ്കിൽ, മൂന്നാമത്തെ പ്ലേറ്റ്

and says that stack or a class stack and I will say that I have l which is of type list

നീക്കംചെയ്യുന്നതിന് മുമ്പ് നിങ്ങൾ ആദ്യ രണ്ട് നീക്കംചെയ്യുന്നു. അതിനാൽ, സ്റ്റാക്കിന് (stack) ധാരാളം നല്ല ആപ്ലിക്കേഷനുകൾ ഉണ്ട്, കൂടാതെ സ്റ്റാക്കിന്റെ

which have I already defined it. This is my private data, then I will define a set of

(stack) ഒരു നിർദ്ദിഷ്ട ആപ്ലിക്കേഷനെക്കുറിച്ച്

operations on stack and what are the operations that I want, I want push, I want pop, I want top and then I want empty. So, what will I do for push now also push x comma what will

(application) ഞങ്ങൾ സംസാരിക്കും. സ്റ്റാക്ക് (stack) പിന്തുണയ്ക്കുന്ന പ്രവർത്തനങ്ങൾ പുഷ് (push), പോപ്പ് (pop), സ്റ്റാക്കിലെ (stack) ടോപ് (top) ഘടകം കണ്ടെത്തുക എന്നിവയാണ്. തന്നിരിക്കുന്ന സ്റ്റാക്ക് (stack) ശൂന്യമാണോ

I do l dot first, what does the l dot first return, it returns the position of the first

എന്ന് പരിശോധിക്കാനും കഴിയും. സാധാരണയായി സ്റ്റാക്ക് (stack) പിന്തുണയ്ക്കുന്ന നാല് ഓപ്പറേഷനുകൾ

element. So, insert it at the first position, then

(operation) ഇവയാണ്, ഇപ്പോൾ സ്റ്റാക്ക് (stack) ഒരു

I can pop, I can pop l dot first. So, this was the most recent element that was inserted,

പ്രത്യേക തരം ലിസ്റ്റായതിനാൽ (list), ഇവിടെ ഒരു ഉദാഹരണം

top will also give me l dot first, pop will be l dot first comma l dot delete l dot first

കാണിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഞാൻ ഇതിനകം തന്നെ ADT ലിസ്റ്റ് (list) നടപ്പിലാക്കിയതിനാൽ, ഒരു സ്റ്റാക്കിനെ (stack) പ്രതിനിധീകരിക്കുന്നതിന് ആ ലിസ്റ്റ് (list) തന്നെ ഉപയോഗിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

and top is l dot first and what should be, empty is if the l dot first equals l dot end,

ഞാൻ അത് എങ്ങനെ ചെയ്യും, ADT ലിസ്റ്റ് (list) നിങ്ങൾ ഇതിനകം ഡീബഗ്ഗ് (debug) ചെയ്തിട്ടുണ്ട്. ADT ലിസ്റ്റ് (list) തന്നെ ഒരു സ്റ്റാക്കായി (stack) ഉപയോഗിക്കാം. അതിനാൽ, ഞാൻ അത് എങ്ങനെ

then I can say that the stack is empty. So, what I have done this process here now, we have all these operations over here and top should be retrieve of top, it should be l

ചെയ്യും, അപ്പോൾ ഞാൻ എന്റെ പ്രവർത്തനങ്ങൾ നിയന്ത്രിക്കും. എ‌ഡി‌ടി സ്റ്റാക്ക് (ADT stack) എഴുതാനും സ്റ്റാക്ക് (stack) അല്ലെങ്കിൽ ക്ലാസ് സ്റ്റാക്ക് (class stack)

dot I would have return to be the retrieve of l dot first, this is how you do implement all these four operations of the stack using the list.

പറയാനും കഴിയും, കൂടാതെ ഞാൻ ഇതിനകം തന്നെ നിർവചിച്ച ടൈപ്പ് (type) ലിസ്റ്റിലുള്ള (list) l ഉണ്ടെന്ന് ഞാൻ പറയും. ഇതാണ് എന്റെ

So, you can use the list ADT in it is present form which you implemented well as the stack ADT and perform the four operations which are required for the stack, now what we will

സ്വകാര്യ ഡാറ്റ (data), തുടർന്ന് ഞാൻ സ്റ്റാക്കിലെ (stack) ഒരു കൂട്ടം പ്രവർത്തനങ്ങൾ നിർവചിക്കും, എനിക്ക് വേണ്ട പ്രവർത്തനങ്ങൾ എന്തൊക്കെയാണ്, പുഷ്

do is somewhat I have this. So, this is one of the thing I am trying to encourage you to do is that basically that if I also have a ADT which is implemented, I try to reuse

(push), പോപ്പ് (pop), ടോപ്പ് (top) എന്നിവയാണ് . തുടർന്ന് എംപ്റ്റി (empty). പുഷ് (push) ചെയ്യുന്നതിനായി

the abstract data type as much as possible. Because, why do I wanted to do that, the primary reason I wanted to do that is the list ADT which we implemented in the last class, we let us say nicely debugged, no errors in it. So, what I will do is I will quickly define a stack using the list and then I will use a stack to perform various operations. What

ഞാൻ ഇപ്പോൾ എന്തുചെയ്യും, push x, l.first. L.first ആദ്യത്തെ മൂലകത്തിന്റെ സ്ഥാനം നൽകുന്നു. ആദ്യ സ്ഥാനത്ത് അത് വെക്കുക. തുടർന്ന്

I am going to do right now is I am going to give you one application of stacks and then

എനിക്ക് പോപ്പ് (pop) ചെയ്യാൻ കഴിയും,

we will look at the implementation of the stack a little later. Let us say I want to convert an infix expression to postfix expression. Let us see, why you want to do this, let us say I have an expression which is given like

എനിക്ക് ആദ്യം പോപ്പ് (pop) ചെയ്യാൻ കഴിയും. ചേർത്ത ഏറ്റവും പുതിയ ഘടകമാണിത്, ടോപ്പ് (top) എനിക്ക് ആദ്യം l.first നൽകും, പോപ്പ് (pop) l.first, l.delete, ടോപ്പ് l.first ആയിരിക്കും. l.first

this. Let us say I am given an expression like this a minus b star c plus d star f plus c by d and suppose we know that, star and slash had higher precedence than minus and

= l.end ആണെങ്കിൽ സ്റ്റാക്ക് (stack) ശൂന്യമാണെന്ന് പറയാൻ കഴിയും. ഞാൻ ഇപ്പോൾ ഇവിടെ ഈ പ്രക്രിയ എന്താണ് ചെയ്തത്, ഈ പ്രവർത്തനങ്ങളെല്ലാം ഇവിടെയുണ്ട്, ടോപ്പിൽ (top) നിന്ന് വീണ്ടെടുക്കണം,

അത് l.first ആയിരിക്കണം. ഇങ്ങനെയാണ് നിങ്ങൾ ലിസ്റ്റ് (list) ഉപയോഗിച്ച് സ്റ്റാക്കിന്റെ

plus and the all operators are left associative. What do we mean by this is that a minus b

(stack) ഈ നാല് പ്രവർത്തനങ്ങളും നടപ്പിലാക്കുന്നത് . നിങ്ങൾ‌ക്ക് അതിൽ ADT ലിസ്റ്റ് (list) ഉപയോഗിക്കാൻ‌ കഴിയും, സ്റ്റാക്ക് എ‌ഡി‌ടിയും (stack ADT) സ്റ്റാക്കിന് ആവശ്യമായ

plus c is equal to a minus b plus c, rather than a minus of b plus c that is we assume

നാല് പ്രവർ‌ത്തനങ്ങളും നിർ‌വ്വഹിക്കുന്നു, അടിസ്ഥാനപരമായി എനിക്കും ഒരു എ‌ഡി‌ടി (ADT) നടപ്പിലാക്കിയിട്ടുണ്ടെങ്കിൽ, അബ്സ്ട്രാക്ട് ഡാറ്റാ (abstarct data) തരം പരമാവധി ഉപയോഗിക്കാൻ ഞാൻ

ശ്രമിക്കുന്നു. ഞാൻ അത് ചെയ്യാൻ ആഗ്രഹിച്ചതിന്റെ പ്രധാന കാരണം ഞങ്ങൾ അവസാന ക്ലാസ്സിൽ നടപ്പിലാക്കിയ ലിസ്റ്റ് (list) ADT ആണ്, ഡീബഗ്ഗ് (debug) ചെയ്തു, അതിൽ പിശകുകളൊന്നുമില്ല. ലിസ്റ്റ് (list) ഉപയോഗിച്ച്

that all the operators associate to the left and this is a meaning of it.

ഒരു സ്റ്റാക്ക് (stack) വേഗത്തിൽ നിർവചിക്കും,

I am given a expression like this I do not know whether I have to perform a minus b plus

തുടർന്ന് വിവിധ പ്രവർത്തനങ്ങൾ നടത്താൻ ഞാൻ ഒരു

c or should I perform a minus of b plus c that is where the associativity matters. What

സ്റ്റാക്ക് (stack) ഉപയോഗിക്കും. ഞാൻ നിങ്ങൾക്ക് സ്റ്റാക്കുകളുടെ (stack) ഒരു ആപ്ലിക്കേഷൻ (application) നൽകാൻ പോകുന്നു,

is the interesting is that when I am given an expression like this and I do not know

തുടർന്ന് കുറച്ച് സമയം കഴിഞ്ഞ് സ്റ്റാക്ക് (stack) നടപ്പിലാക്കുന്നത് പരിശോധിക്കും.

the associativity of the operators, it is difficult to evaluate this expression.

ഒരു ഇൻഫിക്‌സ് എക്‌സ്‌പ്രഷനെ (infix expression) പോസ്റ്റ്‌ഫിക്‌സ്

So, what is done is given a particular expression, the expression is converted to a form called

എക്‌സ്‌പ്രഷനിലേക്ക് (postfix expression) പരിവർത്തനം ചെയ്യണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു. എന്തുകൊണ്ടാണ് നിങ്ങൾ ഇത് ചെയ്യാൻ ആഗ്രഹിക്കുന്നതെന്ന്

the postfix expression. So, let us see what this postfix expressions is all about, let

നമുക്ക് നോക്കാം, എനിക്ക് ഇതുപോലൊരു എക്സ്പ്രെഷൻ (expression) ഉണ്ട്. a-b*c+d*f+c/d * നും

me just take only a partial expression a minus b star c let us say, this will be written

സ്ലാഷിനും (/) മൈനസ് (-), പ്ലസ് (+) എന്നിവയേക്കാൾ ഉയർന്ന മുൻ‌ഗണനയുണ്ട്. എല്ലാ ഓപ്പറേറ്ററും

as a, b, c star minus. What is the meaning of it, we take the top most operator. Then,

(operator) ലെഫ്റ്റ് അസ്സോസിയേറ്റീവ് (left associative) ആണ്. ഇതിനർ‌ത്ഥം, a-b+c എന്നത് (a-b)+c ആണ് a-(b+c) അല്ല.

you come to the next operator and the next one is still an operator, so you push it somewhere, take the next operator, again you use the stack for this. Then, you find on the top

എനിക്ക് ഇതുപോലുള്ള ഒരു എക്സ്പ്രെഷൻ (expression) ഉണ്ട്, എനിക്ക് (a-b)+c ചെയ്യണമോ അതോ (a-b)+c ചെയ്യണോ എന്ന് എനിക്കറിയില്ല, അവിടെയാണ്

there are two operands over here you compute this b star c.

അസോസിയേറ്റിവിറ്റി (associativity) പ്രാധാന്യമുള്ളത്. രസകരമായ ഒരു കാര്യം, ഇതുപോലുള്ള ഒരു ഏക്സ്പ്രെഷൻ

The idea is that what happens is the operator associate with the some binary operator associates

(expression) നൽകുകയും ഓപ്പറേറ്ററുകളുടെ (operator) അസ്സോസിയേറ്റിവിറ്റി (associativity) എനിക്കറിയില്ലെങ്കിൽ, ഈ എക്സ്പ്രെഷൻ (expression)

with the nearest operands that are there. So, what is nice is the advantage of this

വിലയിരുത്താൻ പ്രയാസമാണ്. ഒരു പ്രത്യേക എക്സ്പ്രെഷൻ (expression) നൽകുന്നു, എക്സ്പ്രഷൻ (expression) പോസ്റ്റ്ഫിക്സ്

expression when you write it in this form, there is no issue about the evaluation. Why

എക്സ്പ്രഷൻ (postfix expression) എന്ന രൂപത്തിലേക്ക്

is the no issue about the evaluation? Because, you look at the operator, you just for example,

പരിവർത്തനം ചെയ്യുന്നു. ഈ പോസ്റ്റ്ഫിക്‌സ് എക്‌സ്‌പ്രഷനുകൾ (postfix expression) എന്തിനെക്കുറിച്ചാണെന്ന്

if I keep moving along this as soon as a come across the first operator, all that I will do is I take this operator, operated on these two operands get the result and put it there

നമുക്ക് നോക്കാം, ഒരു ഭാഗിക എക്സ്പ്രെഷൻ (expression) മാത്രം എടുക്കാം a-b*c. ഇത് abc*- ആയി എഴുതപ്പെടും. അതിന്റെ അർത്ഥമെന്താണ്, ഞങ്ങൾ ഏറ്റവും മുകളിൽ

and that we call it d, then I have a d and minus. Then, it means after find I am assume a minus d. So, that is absolutely no ambiguity when a

ഓപ്പറേറ്റർ (operator) എടുക്കുന്നു. തുടർന്ന്, നിങ്ങൾ അടുത്ത മുകളിൽ മുകളിൽ ഉള്ള ഓപ്പറേറ്ററിലേക്ക് (operator) വരുന്നു, അടുത്തത് വീണ്ടും ഒരു ഓപ്പറേറ്ററാണ്

given expression is given in postfix, the order of the operations. Whereas, if I give the expression in this form which is called infix, I do not know whether I am has to perform

(operator), അതിനാൽ നിങ്ങൾ അത് എവിടെയെങ്കിലും പുഷ് (push) ചെയ്യുക, അടുത്ത ഓപ്പറേറ്റർ (operator) എടുക്കുക, വീണ്ടും നിങ്ങൾ ഇതിനായി സ്റ്റാക്ക്

a minus b star c, I do not know the associativity, I do not know the precedence of the operators.

(stack) ഉപയോഗിക്കുന്നു. മുകളിൽ, രണ്ട് ബി ഓപ്പറന്റുകൾ (operand) ഉണ്ട്. b*c കണ്ടുപിടിക്കുക.

Everything is subsumed in the postfix expression. Given a postfix expression all are I have

എന്താണ് സംഭവിക്കുന്നത്, ഓപ്പറേറ്റർ അവിടെയുള്ള ഏറ്റവും അടുത്തുള്ള ഓപ്പറാൻഡുകളുമായി

to do is I traverse that postfix expression from left to right, as soon as I come across

ബന്ധപ്പെട്ടിരിക്കുന്നു എന്നതാണ് ആശയം. ഈ എക്സ്പ്രെഷൻ (expression) നിങ്ങൾ ഈ ഫോമിൽ (form)

an operator I take the nearest two operands, perform the computation, then you can put

എഴുതുമ്പോൾ അതിന്റെ ഗുണം എന്താണ്, മൂല്യനിർണ്ണയത്തെക്കുറിച്ച്

it back on stack, this is the way of evaluating again using the stack.

ഒരു പ്രശ്നവുമില്ല. കാരണം, നിങ്ങൾ ഓപ്പറേറ്റർ

Then, once again the result I have a d and minus on the particular stack, then again

(operator) നോക്കുന്നു, ഉദാഹരണത്തിന്, ആദ്യത്തെ ഓപ്പറേറ്റർ (operator) കണ്ടയുടനെ, ഞാൻ ചെയ്യേണ്ടത്

when I traverse this for example, next I see another operand over here and as soon as I

ഞാൻ ഈ ഓപ്പറേറ്ററെ (opertaor) എടുക്കുക, ഈ രണ്ട്

see another operator over here, then I take the most nearest two operands, perform this

ഓപ്പറാൻഡുകളിൽ (operand) പ്രവർത്തിക്കുന്നത് ഫലം നേടുകയും അത് സ്റ്റാക്കിൽ (stack)

operation and I get the result. So, the evaluation of expressions is normally done using the

ഇടുകയും ചെയ്യുക അത് അവിടെയുണ്ട്, അതിനെ d എന്ന് വിളിക്കുന്നു, അപ്പോൾ എനിക്ക് d

postfix expression. You take an infix expression it is very convenient for us to write. But, what we will do is we take the infix expression, convert the infix expression to

യും മൈനസും ഉണ്ട്. a-d ആണ് ചെയ്യേണ്ടത്. ഒരു നിശ്ചിത എക്സ്പ്രെഷൻ (expression) പോസ്റ്റ്ഫിക്‌സിൽ നൽകുമ്പോൾ പ്രവർത്തനങ്ങളുടെ ക്രമം അവ്യക്തമല്ല.

a postfix expression and then perform the computation. So, now what I am going to show you is the evaluation also can be done using stacks, but it will take one application.

അതേസമയം, ഇൻ‌ഫിക്‌സ് (infix) എന്ന് വിളിക്കുന്ന ഈ ഫോമിൽ‌ (form) ഞാൻ‌ എക്‌സ്‌പ്രഷൻ‌ (expression) നൽ‌കുകയാണെങ്കിൽ‌, എനിക്ക് a-b*c ചെയ്യേണ്ടതുണ്ടോ

We look at conversion of infix to postfix using the stack, let us see how you get this

എന്ന് എനിക്കറിയില്ല, എനിക്ക് അസോസിയേറ്റിവിറ്റി

done. So, what is it done here, when an operand is read that is I am getting this expression here as soon as I find an operand, what am I going to do I am just going to simply place

(associativity) അറിയില്ല, ഓപ്പറേറ്ററുകളുടെ (operator) മുൻ‌ഗണന എനിക്കറിയില്ല. പോസ്റ്റ്ഫിക്സ് എക്സ്പ്രഷനിൽ (postfix expression) എല്ലാം ഉൾക്കൊള്ളുന്നു. ഒരു പോസ്റ്റ്‌ഫിക്‌സ് എക്‌സ്‌പ്രഷൻ‌ (postfix

it on the output. Then, when an operator is read, what do I do, I take this operator, so that means, let us go back to this particular expression, take this expression now I see an operand

expression) നൽ‌കിയാൽ‌, ഞാൻ‌ ചെയ്യേണ്ടത് ആ പോസ്റ്റ്‌ഫിക്‌സ് എക്‌സ്‌പ്രഷൻ‌ (postfix expression) ഇടത്തുനിന്ന് വലത്തോട്ട് സഞ്ചരിക്കുക എന്നതാണ്, ഒരു ഓപ്പറേറ്റർ (operator) കണ്ടയുടനെ ഞാൻ ഏറ്റവും അടുത്തുള്ള

രണ്ട് ഓപ്പറാൻ‌ഡുകൾ‌ (operand) എടുക്കുന്നു, കണക്കുകൂട്ടൽ‌ നടത്തുന്നു, തുടർന്ന്‌ നിങ്ങൾ‌ക്ക്

I put it, this is my output, this is my input, then what do I do I put it to the output.

ഇത് സ്റ്റാക്കിൽ‌ (stack) തിരികെ വയ്ക്കാം, ഇത് സ്റ്റാക്ക് (stack) ഉപയോഗിച്ച് വീണ്ടും വിലയിരുത്തുന്നതിനുള്ള മാർഗമാണ്. സ്റ്റാക്കിൽ (stack) എനിക്ക് a മൈനസും

When an operators read, what I do is I look at the element I have a stack here, right

(-) ഉള്ള ഫലം, അടുത്തതായി ഞാൻ ഇവിടെ മറ്റൊരു ഓപ്പറേഷൻ (operation) കാണുന്നു, ഏറ്റവും അടുത്തുള്ള

now my stack is empty. Look at the element which is there one on the top of the stack, if the top of the stack has higher precedence, then I keep popping all the elements from

രണ്ട് എടുക്കുന്നു പ്രവർത്തിക്കുന്നു, ഈ പ്രവർത്തനം നടത്തുക, എനിക്ക് ഫലം ലഭിക്കും. എക്സ്പ്രഷനുകളുടെ (expression) വിലയിരുത്തൽ സാധാരണയായി പോസ്റ്റ്ഫിക്സ് എക്സ്പ്രഷൻ (postfix expression)

the top of the stack. So, this part is not that, because it is empty, so what I am going to do, I am going to simply

ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്. നിങ്ങൾ ഒരു ഇൻഫിക്‌സ് എക്‌സ്‌പ്രഷൻ (infix expression) എടുക്കുന്നു,

stack the current operator, I put minus on it, then I have b here then what do I see,

അത് എഴുതുന്നത് വളരെ സൗകര്യപ്രദമാണ്. പക്ഷേ, നമ്മൾ ചെയ്യേണ്ടത് ഇൻഫിക്‌സ് എക്‌സ്‌പ്രഷൻ എക്സ്പ്രഷൻ (infix expression) എടുത്ത് ഒരു പോസ്റ്റ്ഫിക്‌സ്

then I have a another operator over here. So, now I look at the

എക്‌സ്‌പ്രഷനായി എക്സ്പ്രഷൻ (posfix expression) പരിവർത്തനം ചെയ്യുക, തുടർന്ന് കണക്കുകൂട്ടൽ നടത്തുക എന്നതാണ്, ഇപ്പോൾ ഞാൻ നിങ്ങളെ

top of the stack this is a minus sign here, minus sign has lower precedence. So, what

കാണിക്കാൻ പോകുന്നത് മൂല്യനിർണ്ണയവും സ്റ്റാക്കുകൾ (stack) ഉപയോഗിച്ച് ചെയ്യാനാകും,

I do I just simply stack star also on to it, then again I see an operand move it to the output. Next what do I see, I see a plus, when I see a plus what I do is the following,

പക്ഷേ ഇതിന് ഒരു ആപ്ലിക്കേഷൻ (application) എടുക്കും. സ്റ്റാക്ക് (stack) ഉപയോഗിച്ച് ഇൻ‌ഫിക്‌സിനെ (infix) പോസ്റ്റ്ഫിക്‌സിലേക്ക് (postfix) പരിവർത്തനം ചെയ്യുന്നത് എങ്ങനെ ചെയ്യാമെന്ന് നോക്കാം. ഇവിടെ എന്താണ്

I look at the content on the top of the stack. So, star is the content on the top of the

ചെയ്യുന്നത്, ഒരു ഓപ്പറന്റ് (operand) കണ്ടെത്തിയയുടനെ എനിക്ക് ഈ എക്സ്പ്രഷൻ (expression) ലഭിക്കുന്നു,

stack, so since star is a content on the top of the stack I output and star has higher

ഞാൻ എന്താണ് ചെയ്യാൻ പോകുന്നത് ഞാൻ അത് ഔട്ട്‌പുട്ടിൽ (output) സ്ഥാപിക്കാൻ പോകുന്നു.

precedence. So, the precedence is like this star comma slash and plus comma minus and of course, above this you have the brackets. So, what I do is I pop the star. Then, once

തുടർന്ന്, ഒരു ഓപ്പറേറ്റർ (operator) കാണുമ്പോൾ, ഞാൻ എന്തുചെയ്യും, ഞാൻ ഈ ഓപ്പറേറ്റർ (operator) എടുക്കുന്നു, അതിനാൽ ഇതിനർത്ഥം, നമുക്ക് ഈ പ്രത്യേക എക്സ്പ്രഷനിലേക്ക് (expression) മടങ്ങാം, ഈ എക്സ്പ്രഷൻ

since I pop the star what do I have, I only have minus on top of the stack. What the current

(expression) എടുക്കുക ഇപ്പോൾ ഞാൻ ഇട്ട ഒരു ഓപ്പറന്റ്

operator that I am looking at plus, now clearly plus and minus have same precedence.

(operand) കാണുന്നു, ഇതാണ് എന്റെ ഔട്ട്പുട്ട്

So, what I do I also pop the minus, then what I do I put this plus over here onto the stack

(output), ഇത് എന്റെ ഇൻ‌പുട്ട് (input), പിന്നെ ഞാൻ എന്തുചെയ്യും ഔട്ട്‌പുട്ടിൽ (output) ഇടുക. ഒരു ഓപ്പറേറ്റർ

and with precedence, this is how this whole operation course about. So, basically this

(operator) കാണുമ്പോൾ ഞാൻ ചെയ്യുന്നത് എനിക്ക് ഇവിടെ ഒരു സ്റ്റാക്ക് (stack) ഉള്ള ഘടകത്തിലേക്ക്

is what we do and now I have done, up till this part of the expression. Now, let us look

നോക്കുകയാണ്, ഇപ്പോൾ എന്റെ സ്റ്റാക്ക് (stack) ശൂന്യമാണ്. സ്റ്റാക്കിന്റെ (stack) മുകളിൽ ഒന്ന്

at the next one what do I have now, the plus is gone it is gone to the stack, I get d I

ഉള്ള മൂലകം നോക്കൂ, സ്റ്റാക്കിന് (stack) മുകളിൽ ഉയർന്ന മുൻ‌ഗണന ഉണ്ടെങ്കിൽ, ഞാൻ

push this on to the stack. Then, what do I have, I have a left bracket I put the left

എല്ലാ ഘടകങ്ങളും സ്റ്റാക്കിന്റെ (stack) മുകളിൽ നിന്ന് പോപ്പ് (pop) ചെയ്യുന്നു.

bracket also on to the stack. Then, what do I have, I have a right, then

ഈ ഭാഗം അങ്ങനെയല്ല, കാരണം ഇത് ശൂന്യമാണ്, അതിനാൽ ഞാൻ എന്താണ് ചെയ്യാൻ പോകുന്നത്,

I put the plus on to the stack, then I have c d, then I have a slash over here and compare

ഞാൻ നിലവിലെ ഓപ്പറേറ്റർ (operator) സ്റ്റാക്കു (stack) ചെയ്യാൻ പോകുന്നു, ഞാൻ അതിൽ മൈനസ് (-) ഇടുന്നു, അതിനുശേഷം എനിക്ക് ഇവിടെ ബി ഉണ്ട്, പിന്നെ

with what is there, put it on the top of the stack, then what happens I come across the

ഞാൻ എന്താണ് കാണുന്നത്, പിന്നെ മറ്റൊരു ഓപ്പറേറ്റർ

right bracket. So, as soon as we come across the right bracket I pop everything of until I see the left bracket that mean I put the slash here, I put the plus here and then what

(operator) ഇവിടെയുണ്ട്. അതിനാൽ, ഇപ്പോൾ ഞാൻ സ്റ്റാക്കിന്റെ (stack) മുകളിൽ നോക്കുന്നു, ഇവിടെ ഒരു മൈനസ് (-) ചിഹ്നമാണ്, മൈനസ് ചിഹ്നത്തിന് മുൻ‌ഗണന കുറവാണ്. അതിനാൽ,

do I do, I come to the end of the expression star and plus. So, this is how I complete

ഞാൻ ചെയ്യുന്നത് ഞാൻ അതിലേക്ക് * വയ്ക്കുന്നു, തുടർന്ന് വീണ്ടും ഒരു ഓപ്പറന്റ് (operand)

the expression.

അതിനെ ഔട്ട്‌പുട്ടിലേക്ക് (output) നീക്കുന്നത്

So, this is the conversion from infix to postfix. So, what we have done, we took the infix expression, then we converted it to a postfix expression using a stack. Now, let us see if it will

ഞാൻ കാണുന്നു. അടുത്തതായി ഞാൻ എന്താണ് കാണുന്നത്, ഒരു പ്ലസ് (+) കാണുന്നു, പ്ലസ് (+) കാണുമ്പോൾ ഞാൻ ചെയ്യുന്നത് ഇനിപ്പറയുന്നവയാണ്,

give us the evaluation correctly, what did I say. I just keep this as it is, then as

സ്റ്റാക്കിന്റെ (stack) മുകളിലുള്ള ഉള്ളടക്കം ഞാൻ നോക്കുന്നു. * എന്നത് സ്റ്റാക്കിന്റെ

soon as I see an operator I find the nearest two operands and compute the computation.

(stack) മുകളിലുള്ള ഉള്ളടക്കമാണ്, അതിനാൽ * മുകളിലുള്ള ഉള്ളടക്കമായതിനാൽ * ന് ഉയർന്ന മുൻ‌ഗണനയുണ്ട്.

Let me call this b operand that is I computed these two and let us say this result is b

അതിനാൽ, മുൻ‌ഗണന ഈ *, / +,- പോലെയാണ്, തീർച്ചയായും

prime, then what do I have, I have a b minus. Now, clearly there are there are two operands

ഇതിന് മുകളിൽ ബ്രാക്കറ്റുകൾ ഉണ്ട്. അതിനാൽ, ഞാൻ ചെയ്യുന്നത് ഞാൻ * പോപ്പ് ചെയ്യുക

and there is an operator, so I compute this let me call this a prime. So, what do I have now, I have already computed this, now I have d f c d slash plus star plus, so what do I

എന്നതാണ്. ഒരിക്കൽ, ഞാൻ * പോപ്പ് (pop) ചെയ്തതിനുശേഷം, സ്റ്റാക്കിന് (stack) മുകളിൽ എനിക്ക് മൈനസ് മാത്രമേയുള്ളൂ. ഞാൻ നോക്കുന്ന നിലവിലെ ഓപ്പറേറ്ററിന് (operator) എന്താണ്, പ്ലസ്, മൈനസ്

എന്നിവയ്ക്ക് ഒരേ മുൻ‌ഗണനയുണ്ട്.

do now, I keep moving from left, this is computed let me call it is c prime, then I have f c

അതിനാൽ, ഞാൻ മൈനസ് പോപ്പ് (pop) ചെയ്യുന്നു, തുടർന്ന് ഈ പ്ലസ് ഇവിടെ സ്റ്റാക്കിലേക്ക്

prime d a prime. So, what do I do, I compute this let me call this f prime, so I have a

(stack) വയ്ക്കുന്നത്, മുൻ‌ഗണനയോടെ, ഈ മുഴുവൻ ഓപ്പറേഷൻ കോഴ്‌സും (operation course) ഇങ്ങനെയാണ്.

prime d, f prime plus and sorry,plus is already gone, d prime plus f plus c d.

അതിനാൽ, അടിസ്ഥാനപരമായി ഇതാണ് ഞങ്ങൾ ചെയ്യുന്നത്, ഇപ്പോൾ ഞാൻ ചെയ്തു, അടുത്തത് ഇപ്പോൾ നമുക്ക് എന്താണ് ഉള്ളതെന്ന് നോക്കാം, പ്ലസ് പോയി, അത് സ്റ്റാക്കിലേക്ക് (stack) പോയി, എനിക്ക്

d ലഭിക്കുന്നു ഞാൻ ഇത് സ്റ്റാക്കിലേക്ക്

I already computed this sum over here and then I have a star over here and a minus. So, next what do I do, I compute a prime d f prime let me call it d prime after the multiplication,

(stack) നീക്കുന്നു. പിന്നെ, എനിക്ക് എന്താണ് ഉള്ളത്, എനിക്ക് ഒരു ഇടത് ബ്രാക്കറ്റ് ഉണ്ട്, ഇടത് ബ്രാക്കറ്റും ഞാൻ സ്റ്റാക്കിൽ (stack) ഇട്ടു. അതിനു ശേഷം a ഉണ്ട്.

because I see the multiplication here, multiply these two put the result in d prime I have

തുടർന്ന് ഞാൻ സ്റ്റാക്കിലേക്ക് (stack) പ്ലസ് ഇട്ടു, പിന്നെ c d ഉണ്ട്, പിന്നെ സ്ലാഷ് (/) ഉണ്ട്, അവിടെയുള്ളതുമായി

a minus and now finally I and get the result which is essentially what the...

താരതമ്യപ്പെടുത്തുക, സ്റ്റാക്കിന്റെ മുകളിൽ വയ്ക്കുക, അപ്പോൾ എന്ത് സംഭവിക്കും

So, basically what it tells is if I follow the rules of arithmetic for a postfix gives

ഞാൻ റൈറ്റ് ബ്രാക്കറ്റ് (right bracket) കാണുന്നു. റൈറ്റ് ബ്രാക്കറ്റിലൂടെ (right bracket) കടന്നുപോകുമ്പോൾ

expression, what is a rule say I take theů whenever I see an operator, I take the nearest two operands, perform the computation and store it. Then, what happens that becomes

ലെഫ്റ്റ് ബ്രാക്കറ്റ് (left bracket) കാണുന്നതുവരെ എല്ലാം പോപ്പ് (pop) ചെയ്യുന്നു, അതിനർത്ഥം ഞാൻ ഇവിടെ സ്ലാഷ് (/) ഇട്ടു, പ്ലസ് (+) ഇട്ടു, തുടർന്ന് എന്തുചെയ്യും, എക്സ്പ്രഷന്റെ (expression)

അവസാനത്തിൽ വരുന്നു *, + . ഇങ്ങനെയാണ് ഞാൻ

a new operand now b prime, then a and b prime and this is an operator here minus. So, I

എക്സ്പ്രഷൻ (expression) പൂർത്തിയാക്കുന്നത്. ഇൻഫിക്‌സിൽ (infix) നിന്ന് പോസ്റ്റ്ഫിക്‌സിലേക്കുള്ള (postfix) പരിവർത്തനമാണിത്. ഞങ്ങൾ ഇൻഫിക്‌സ്

compute the difference of a and b prime, again I put it back on top. So, then I call it a

എക്‌സ്‌പ്രഷൻ (infix expression) എടുത്തു, തുടർന്ന് ഒരു സ്റ്റാക്ക് (stack) ഉപയോഗിച്ച് ഒരു പോസ്റ്റ്ഫിക്‌സ്

prime, then what happens I have d f c d, I just put them all together, then I see a slash.

എക്‌സ്‌പ്രഷനിലേക്ക് (postfix expression) പരിവർത്തനം ചെയ്‌തു. ഇപ്പോൾ, ഇത് മൂല്യനിർണ്ണയം

When I see a slash what do I do, I take the nearest two operands, multi divide them, here

ശരിയായി നൽകുമോ എന്ന് നോക്കാം, ഞാനിത് അതേപടി നിലനിർത്തുന്നു, ഒരു ഓപ്പറേറ്റർ (operator) കണ്ടയുടനെ ഞാൻ ഏറ്റവും അടുത്തുള്ള രണ്ട്

the operators slash, so I divide c by d I call it c prime. Then, I have a prime d f

ഓപ്പറാൻഡുകൾ (operand) കണ്ടെത്തി കണക്കുകൂട്ടൽ ന്നു. ഈ b ഓപ്പറാൻഡിനെ (operand) ഞാൻ വിളിക്കാം, ഇവ രണ്ടും കണക്കുകൂട്ടി ഈ ഫലം b’ ആണെന്ന് നമുക്ക്

c prime, then what happens I have f and c prime. So, this is this part, so I add them

പറയാം, പിന്നെ ഒരു ബി മൈനസ് (b minus) ഉണ്ട്. ഇപ്പോൾ, രണ്ട് ഓപ്പറെൻഡുകളുണ്ട് (operand), ഒരു ഓപ്പറേറ്ററുമുണ്ട് (operator), ഇത് a പ്രൈം (a’) എന്ന് വിളിക്കാൻ എന്നെ അനുവദിക്കുക. എനിക്ക് ഇപ്പോൾ എന്താണ്

then what do I had a prime d f prime let me call it, then d f prime star this star is here. So, I perform this computation and because that is the first operator that I am seeing

ഉള്ളത്, ഞാൻ ഇത് ഇതിനകം കണക്കുകൂട്ടി, ഇപ്പോൾ എനിക്ക് dfcd / + * + ഉണ്ട്, ഇപ്പോൾ എന്തുചെയ്യും, ഞാൻ ഇടത് നിന്ന് നീങ്ങുന്നു, ഇത്

I take the nearest two operands perform the computation, then finally I get let me call

കണക്കുകൂട്ടുന്നു, ഇത് സി പ്രൈം (c’) എന്ന് വിളിക്കട്ടെ, പിന്നെ എനിക്ക് fc’da’ ഉണ്ട്.

it I got a new operator, operand called d prime and a prime d prime and I subtracts one from the other and the postfix expression can be evaluated.

എഫ് പ്രൈം കണക്കാക്കുന്നു, അതിനാൽ എനിക്ക് d’+f’+cd. ഞാൻ ഇതിനകം തന്നെ ഈ തുക ഇവിടെ കണക്കുകൂട്ടി,

So, clearly what it tells me is using the algorithm that I have given here, the conversion

അതിനുശേഷം എനിക്ക് ഇവിടെ ഒരു * ഒരു മൈനസും ഉണ്ട്. അടുത്തതായി ഞാൻ a’df’ കണക്കുകൂട്ടുന്നു, ഗുണനത്തിന് ശേഷം അതിനെ d’ എന്ന് വിളിക്കട്ടെ,

to infix to postfix is correct. So, basically I can use a stack to take this input convert

ഇവിടെ ഗുണനം കാണുന്നു, ഇവ രണ്ടും ഗുണിച്ചാൽ ഫലം d പ്രൈമിൽ (d’)ഇടുന്നു. ഒരു മൈനസ് ഉണ്ട്.

it to postfix. So, whatever you doing when you doing this, we are taking all the operators,

അടിസ്ഥാനപരമായി അത് പറയുന്നത് ഒരു പോസ്റ്റ്ഫിക്സിനായി (postfix) ഞാൻ ഗണിത നിയമങ്ങൾ

stacking the operators including brackets and when do we pop as soon as we come across

പാലിക്കുകയാണെങ്കിൽ ഒരു റൂൾ (rule) എന്താണ് എടുക്കുന്നതെന്ന് പറയുന്നു. ഞാൻ ഒരു ഓപ്പറേറ്റർ (operator) കാണുമ്പോഴെല്ലാം,

an operator which has lower precedence than what is there in the stack, I pop all the

ഏറ്റവും അടുത്തുള്ള രണ്ട് ഓപ്പറാൻഡുകൾ (operand) എടുക്കുകയും കണക്കുകൂട്ടൽ നടത്തുകയും സംഭരിക്കുകയും ചെയ്യുന്നു. പിന്നെ, എന്ത് സംഭവിക്കുന്നു

operators from the stack which have higher precedence and the operators which have the

ഇപ്പോൾ ഒരു പുതിയ ഓപ്പറാൻഡായി (operand) മാറുന്നു b പ്രൈം (b’), പിന്നെ a, b പ്രൈം

same precedence too and put this operator on to the stack that is exactly what we did.

(b’), ഇത് ഇവിടെ ഒരു ഓപ്പറേറ്ററാണ് (operator) മൈനസ്. അതിനാൽ, എ, ബി പ്രൈമിന്റെ (b’) വ്യത്യാസം ഞാൻ കണക്കുകൂട്ടുന്നു, വീണ്ടും ഞാൻ അതിനെ മുകളിൽ ഇടുന്നു. ഞാൻ അതിനെ a പ്രൈം

എന്ന് വിളിക്കുന്നു, പിന്നെ എന്ത് സംഭവിക്കും

Let me illustrate this with the pictorial example again. So, let us say we have the same I have a same almost the same expression which I have already gone through over here and never realize it. This is the same expression that is there

എനിക്ക് d f c d ഉണ്ട്, ഞാൻ അവയെല്ലാം ഒരുമിച്ച് ചേർത്തു, തുടർന്ന് ഞാൻ ഒരു സ്ലാഷ് (/) കാണുന്നു. ഞാൻ ഒരു സ്ലാഷ് (/) കാണുമ്പോൾ, ഏറ്റവും അടുത്തുള്ള

and here is a pictorial description of what is exactly happening stack the plus, this

രണ്ട് ഓപ്പറാൻഡുകൾ (operand) എടുക്കുന്നു, അവയെ വിഭജിക്കുന്നു, ഇവിടെ ഓപ്പറേറ്റർ

is the top of the stack, then a is kept outside and then you get a, b, c then you put a, b, c star, pop this and so on. So, this is how your output gets generated. As soon as you

(operator) സ്ലാഷ് (/). അതിനാൽ ഞാൻ സി കൊണ്ട് ഡി കൊണ്ട് ഹരിക്കുന്നു, അതിനെ സി പ്രൈം (c’) എന്ന് വിളിക്കുന്നു. പിന്നെ, എനിക്ക്

see a bracket you just push everything out. So, this is how you convert and invert... So, basically this is the first thing whether the stack is a stack of operators. So, what

a’dfc’ ഉണ്ട്, പിന്നെ എന്ത് സംഭവിക്കും എനിക്ക് f,c’ ഉണ്ട്. ഞാൻ അവരെ ചേർക്കുന്നു, അപ്പോൾ a’df’, തുടർന്ന് * ഇവിടെയുണ്ട്. ഞാൻ

is happening now plus and star has stack, then as soon as the next plus comes you pop both plus and star, just I was already told to you and then you see the bracket, you put

ഈ കണക്കുകൂട്ടൽ നടത്തുന്നു, കാരണം ആദ്യത്തെ ഓപ്പറേറ്റർ (operator) ആയതിനാൽ ഞാൻ ഏറ്റവും അടുത്തുള്ള രണ്ട് ഓപ്പറന്റുകൾ (operand) എടുത്ത് കണക്കുകൂട്ടൽ

the bracket on top of the stack and repeat the same process again. So, this is essentially

നടത്തുന്നു, ഒടുവിൽ എനിക്ക് ഒരു പുതിയ ഓപ്പറേറ്റർ (operator) ലഭിച്ചു, d’. a’d’. ഞാൻ

how stack can be used. Now, let us look at the implementation of the stack and what are the operations, I am looking at a separate implementation. Let us say that I am not going to use the list,

ഒരെണ്ണം മറ്റൊന്നിൽ നിന്ന് കുറയ്ക്കുകയും പോസ്റ്റ്ഫിക്സ് എക്സ്പ്രഷൻ (postfix expression) വിലയിരുത്തുകയും ചെയ്യാം. ഞാൻ ഇവിടെ നൽകിയ അൽ‌ഗോരിതം (algorithm) ഉപയോഗിക്കുന്നു,

ഇൻ‌ഫിക്‌സിലേക്ക് (infix) പോസ്റ്റ്ഫിക്‌സിലേക്ക്

I want to implement my own stack. Before that what are time complexity of these operations

(postfix) പരിവർത്തനം ചെയ്യുന്നത് ശരിയാണ്. അടിസ്ഥാനപരമായി എനിക്ക് ഈ ഇൻപുട്ട് (input) എടുക്കാൻ പോസ്റ്റ്ഫിക്‌സിലേക്ക്

when look at l dot insert, l dot delete, l dot retrieve, what will be the time complexity

പരിവർത്തനം ചെയ്യാൻ ഒരു സ്റ്റാക്ക് (stack) ഉപയോഗിക്കാം. ഇത് ചെയ്യുമ്പോൾ എല്ലാ

of all of these, if you can see if you look at the, it depends upon the kind of implementation.

ഓപ്പറേറ്ററും (operator) എടുക്കുന്നു, ബ്രാക്കറ്റുകൾ ഉൾപ്പെടെയുള്ള ഓപ്പറേറ്റർ (operator) സ്റ്റാക്കു

If the implementation is a linked list it does not matter, doing this particular case

(stack) ചെയ്യുന്നു, ഒപ്പം സ്റ്റാക്കിലുള്ളതിനേക്കാൾ (stack) കുറഞ്ഞ മുൻ‌ഗണനയുള്ള ഒരു ഓപ്പറേറ്റർ (operator)

I am inserting at the first, all these operations can also be done in order one type, even when

കാണുമ്പോൾ പോപ്പ് (pop) ചെയ്യുന്നു, ഉയർന്ന മുൻ‌ഗണനയുള്ള ഓപ്പറേറ്ററും (operator) സമാന മുൻ‌ഗണനയുള്ള

I am using the list. But, we can do a cleaner implementation, we can implement a stack.

ഓപ്പറേറ്ററും (operator) പോപ്പ് (pop) ചെയ്യുന്നു. ചിത്രപരമായ ഉദാഹരണത്തിലൂടെ ഞാൻ ഇത് വീണ്ടും

So, since that in this particular example I am using the operators I have created a

വിശദീകരിക്കാം. സമാനമായ ഒരു പദപ്രയോഗമുണ്ട്, കൃത്യമായി എന്താണ്

stack which is I am using an array implementation here, this is your static array.

സംഭവിക്കുന്നതെന്നതിന്റെ ചിത്രീകരണ വിവരണമാണ് പ്ലസ്, ഇത് സ്റ്റാക്കിന്റെ (stack) മുകളിലാണ്, തുടർന്ന്

So, basically the stacks size here, see you would also like to have a stack full perhaps.

a പുറത്ത് സൂക്ഷിക്കുന്നു, തുടർന്ന് a, b, c, തുടർന്ന് a, b, c, * , b, c *, ഇത് പോപ്പ് (pop) ചെയ്യുക തുടങ്ങിയവ. ഔട്ട്‌പുട്ട് (output) ജനറേറ്റു (generate) ചെയ്യുന്നത്

So, I create or you resize the stack, if you want it to be transparent you can always resizes

ഇങ്ങനെയാണ്. ഒരു ബ്രാക്കറ്റ് (bracket) കണ്ടയുടനെ എല്ലാം പുറത്തേക്ക് പുഷ് (push) ചെയ്യുക. പരിവർത്തനം ചെയ്യുന്നത് ഇങ്ങനെയാണ്.

the stack. Then, you create an empty stack which is make null, then you push the character

അടിസ്ഥാനപരമായി ഇത് സ്റ്റാക്ക് (stack) ഓപ്പറേറ്ററുകളുടെ (operator) ഒരു സ്റ്റാക്ക് (stack) ആണോ. ഇപ്പോൾ എന്താണ് സംഭവിക്കുന്നത്

on to the stack, character pop returns the top most element on the stack, pop deletes

+, * എന്നിവയ്ക്ക് സ്റ്റാക്ക് (stack) ഉണ്ട്, അടുത്ത + വരുന്ന ഉടൻ തന്നെ പ്ലസും * ഉം

the element from the top of the stack, empty tells you that the stack is empty. From here

പോപ്പ് (pop) ചെയ്യുന്നു, ഞാൻ ഇതിനകം നിങ്ങളോട് പറഞ്ഞിരുന്നു, തുടർന്ന് ബ്രാക്കറ്റ് (bracket) കാണുന്നു, ബ്രാക്കറ്റ് (bracket) സ്റ്റാക്കിന്

is how the various operations can be performed and basically what is interesting is all the

(stack) മുകളിൽ ഇടുക അതേ പ്രക്രിയ വീണ്ടും ആവർത്തിക്കുക. സ്റ്റാക്ക് (stack) എങ്ങനെ ഉപയോഗിക്കാമെന്നത് ഇതാണ്. സ്റ്റാക്കിന്റെ (stack) നടപ്പാക്കലും

പ്രവർത്തനങ്ങളും എന്തൊക്കെയാണെന്ന് നോക്കാം, ഞാൻ ഒരു പ്രത്യേക നടപ്പാക്കലിനായി

operands, operations here, if you look at this.

നോക്കുകയാണ്. ഞാൻ ലിസ്റ്റ് (list) ഉപയോഗിക്കാൻ പോകുന്നില്ല, എന്റെ സ്വന്തം സ്റ്റാക്ക്

If you look at the analysis of this I want you to go through this over here, make null

(stack) നടപ്പിലാക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. അതിനുമുമ്പ് l.insert, l.delete, l.retrieve ഇവയുടെ ടൈം

it is simply creates the top of the stack to be stack size. Then, we just putting from

കോംപ്ലക്സിറ്റി (time complexity) എന്തായിരിക്കുമെന്ന് നോക്കുമ്പോൾ അത് നടപ്പിലാക്കലിനെ ആശ്രയിച്ചിരിക്കുന്നു നടപ്പിലാക്കൽ ഒരു

pushing from the stack, what are we doing we here in push for example, I making the

ലിങ്ക്ഡ് ലിസ്റ്റാണെങ്കിൽ (linked list) അത് പ്രശ്‌നമല്ല, ഞാൻ ആദ്യം ഇൻസേർട്ട് (insert) ചെയ്യുന്ന ഈ പ്രത്യേക

stack size, the top of stack initially match to the largest element possible in the array,

കേസ് (case) ചെയ്യുന്നത്, ലിസ്റ്റ് (list) ഉപയോഗിക്കുമ്പോഴും ഈ പ്രവർത്തനങ്ങളെല്ലാം ഒരു തരം ക്രമത്തിൽ ചെയ്യാനാകും. ഈ പ്രത്യേക ഉദാഹരണത്തിൽ ഞാൻ

largest index possible in the array, then what we do, we decrement the top of the stack

ഓപ്പറേറ്റർ (operator) ഉപയോഗിക്കുന്നതിനാൽ ഒരു സ്റ്റാക്ക് (stack) സൃഷ്ടിച്ചു, ഞാൻ ഇവിടെ ഒരു അറേ (array) നടപ്പിലാക്കൽ ഉപയോഗിക്കുന്നു,

and then push the element there and then when we... So, this is again an order one operation

ഇതാണ് നിങ്ങളുടെ സ്റ്റാറ്റിക് അറേ (static array). അടിസ്ഥാനപരമായി ഇവിടെ സ്റ്റാക്കുകളുടെ (stack) വലുപ്പം, ഒരു സ്റ്റാക്ക് (stack) നിറഞ്ഞിരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെന്ന്

കാണുക. അതിനാൽ, ഞാൻ സ്റ്റാക്ക് (stack) സൃഷ്ടിക്കുകയോ

if you notice, this is an order one operation, this is an order one operation.

അല്ലെങ്കിൽ വലുപ്പം മാറ്റുകയോ ചെയ്യുക, അത് സുതാര്യമാകണമെങ്കിൽ നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും സ്റ്റാക്കിന്റെ (stack) വലുപ്പം മാറ്റാനാകും.

Then, what we are doing if the top of stack is less than stack size, it is returning the

നിങ്ങൾ ശൂന്യമായ ഒരു സ്റ്റാക്ക് (stack) സൃഷ്ടിക്കുന്നു, തുടർന്ന് നിങ്ങൾ കാരക്ടർ (character) സ്റ്റാക്കിലേക്ക് (stack) നീക്കുന്നു, ക്യാരക്ടർ

top of stack that mean, otherwise what is happening when you performing a top operation,

(character) പോപ്പ് (pop) സ്റ്റാക്കിലെ (stack) ഏറ്റവും ടോപ്പ്

that is no element in the stack that is the meaning of this return 0 over here. Then,

(top) മൂലകം നൽകുന്നു, പോപ്പ് (pop) സ്റ്റാക്കിന്റെ (stack) മുകളിൽ നിന്ന് മൂലകം ഇല്ലാതാക്കുന്നു,

if top of stack greater than stack size returns 0 again; otherwise, what are we doing you

എംപ്റ്റി സ്റ്റാക്ക് (empty stack) പറയുന്നു ശൂന്യമാണ്. ഇതിന്റെ വിശകലനം നോക്കുകയാണെങ്കിൽ‌,

are popping the particular element on the stack, that is when you are trying to pop

ഇത് സ്റ്റാക്കിന്റെ (stack) ടോപ്പ് (top) സ്റ്റാക്ക്

more elements than there are, otherwise if there is an elements on the stack, it pops

സൈസ് (stack size) ആയി മാറ്റുന്നു. പുഷ് (push) ചെയ്യാൻ സ്റ്റാക്കിന്റെ (stack) ടോപ്പ് (top) തുടക്കത്തിൽ

this. Then, if stack is empty, it is top of stack is greater than stack size, then you say return

അറേയിൽ (array) സാധ്യമായ ഏറ്റവും വലിയ ഇൻഡെക്സുമായി (index) പൊരുത്തപ്പെടുന്നു, സ്റ്റാക്കിന്റെ (stack) ടോപ്പ് (top) കുറയ്ക്കുകയും തുടർന്ന് എലമെൻറ്

greater than or equal to stack size, then you say that the stack is empty. For the time

(element) അവിടെ പുഷ് (push) ചെയ്യുകയും ചെയ്യുന്നു.

complexity of all the operations, there are performance stacks using array is order one.

ഇത് O(1) ഓപ്പറേഷനാണ് (operation). സ്റ്റാക്കിന്റെ (stack) ടോപ്പ് (top) സ്റ്റാക്കിന്റെ (stack) വലുപ്പത്തേക്കാൾ കുറവാണെങ്കിൽ എന്താണ്

Now, what I want you to do is I want you to go back and implement the stack, I given you

ചെയ്യുന്നത്, അത് ടോപ്പ് (top) റിട്ടേൺ (return) ചെയ്യുന്നു. സ്റ്റാക്കിൽ (stack) ഒരു ഘടകവും ഇല്ലെങ്കിൽ 0 റിട്ടേൺ (return) ചെയ്യുന്നു. ടോപ്പ് (top) സ്റ്റാക്കിന്റെ

an array implementation of stacks I want you to do a link list implementation of stack

(stack) വലുപ്പത്തേക്കാൾ കൂടുതലാണെങ്കിൽ 0 റിട്ടേൺ (return) ചെയ്യുന്നു. അല്ലാത്തപക്ഷം, ഘടകത്തെ സ്റ്റാക്കിൽ (stack) നിന്ന് പോപ്പ് (pop) ചെയ്യുകയാണ്, ഉള്ളതിനേക്കാൾ കൂടുതൽ ഘടകങ്ങൾ പോപ്പ്

and all operations must cost the order one. So,

(pop) ചെയ്യാൻ ശ്രമിക്കുമ്പോഴാണ്, അല്ലാത്തപക്ഷം സ്റ്റാക്കിൽ (stack) ഒരു ഘടകമുണ്ടെങ്കിൽ, ഇത് പോപ്പ് (pop)ചെയ്യുന്നു. ടോപ്പ് സ്റ്റാക്ക് വലുപ്പത്തേക്കാൾ വലുതാണെങ്കിൽ വലുതോ തുല്യമോ ആണെന്നു

നിങ്ങൾ പറയുന്നു, തുടർന്ന് സ്റ്റാക്ക് ശൂന്യമാണെന്ന് നിങ്ങൾ പറയുന്നു. എല്ലാ പ്രവർത്തനങ്ങളുടെയും ടൈം കോംപ്ലക്സിറ്റി O(1) ആണ്.

നിങ്ങൾ തിരികെ പോയി സ്റ്റാക്ക് (stack) നടപ്പിലാക്കുക,

I want you to do go back and experiment this. Now, what I want to do is I will just close

സ്റ്റാക്കുകളുടെ (stack) ഒരു അറേ (array) നടപ്പാക്കൽ ഞാൻ നൽകി, സ്റ്റാക്കിന്റെ (stack) ഒരു ലിങ്ക്ഡ്

this with some applications.

ലിസ്റ്റ് (linked list) നടപ്പിലാക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു,

Now, I want you to do this, right now we looked at operations, we only operators we only looked

ഒപ്പം എല്ലാ പ്രവർത്തനങ്ങൾക്കും വില O(1) ആയിരിക്കണം. നിങ്ങൾ തിരികെ പോയി ഇത് പരീക്ഷിക്കുക. നമ്മൾ പ്രവർത്തനങ്ങൾ നോക്കി, ലെഫ്റ്റ്

at left associative operators. What happens if an operator associates to the right, let

അസ്സോസിയേറ്റീവ് ഓപ്പറേറ്റർ (left associative operator) മാത്രം നോക്കിയത്. ഒരു ഓപ്പറേറ്റർ (operator) വലതുവശത്ത് ബന്ധപ്പെടുത്തിയാൽ എന്ത് സംഭവിക്കും, ഞാൻ ഒരു ഉദാഹരണം തരാം.

me give you an example.

ഒരു ഉദാഹരണം നോക്കാം z ഇത് ആണ്. റൈറ്റ് അസ്സോസിയേറ്റീവ് ഓപ്പറേറ്ററുകൾ (right associative operator) ആണെങ്കിൽ എങ്ങനെയാണ് സ്റ്റാക്ക്

If I had an example like this x to the power of y to the power of zx^(y^z ), then what

(stack) ഉപയോഗിക്കുന്നത്, പോസ്റ്റ്ഫിക്‌സ് കൺവെർട്ടറിലേക്ക് (postfix converter) ഇൻഫിക്സ്

is this, this is essentially y to the power of z whole x to power of(x^((y^z ) ) ). So, I want you to think of this how would you use is stack, how would you modify the infix to postfix converter, if you worked with operators which are right associative. The other function

(infix) എങ്ങനെ പരിഷ്കരിക്കും എന്ന് നിങ്ങൾ ചിന്തിക്കുക. ഒരു സി പ്രോഗ്രാമിൽ (C program) പരാൻതീസിസ് (parenthesis) സന്തുലിതമാണോ എന്ന് നിർണ്ണയിക്കുക എന്നതാണ് നിങ്ങൾ എഴുതാൻ ആഗ്രഹിക്കുന്ന

that I would like you to write is to determine whether the parentheses are balanced in a

മറ്റൊരു പ്രവർത്തനം. ഒരു പോസ്റ്റ്ഫിക്സ്

C program. I want you to look at all these types of parenthesis. I also want you to write a function that uses a stack you already talked about it to evaluate a postfix expression.

എക്സ്പ്രഷൻ (postfix expression) വിലയിരുത്തുന്നതിന് സ്റ്റാക്ക് ഉപയോഗിക്കുന്ന ഒരു ഫംഗ്ഷൻ (function) എഴുതാനും ഞാൻ ആഗ്രഹിക്കുന്നു.