 Welcome to the course of data structures and algorithms. We will now be examining implementation of stack data structures. We have three consecutive sessions. In this first session, we will just do a basic review of the stack structure. As you are all aware, this is an example of a stack of plates and we cannot take out a plate from somewhere in between nor we can easily insert a plate somewhere in between. So, the fundamental characteristic of a stack is that we can only remove a plate from the top or add one more plate on top. That means we can push an element on the stack or pop an element out of the stack. It is important to remember that these are the only two actions that are permitted. Of course, we will not be dealing with stack of plates. We will instead be dealing with stack of elements such as integer numbers, characters, character strings or whatever. So, in short, a stack structure permits us to push a data element on top of stack or pop the topmost data element out of stack. This stack implementation will require us that we should not only implement the activities of push and pop, which are the main actions. We will need some additional actions. For example, in a program we need to create a stack. Now, this will require defining a stack and initializing a stack. Similarly, when we are dealing with stack, we need to examine the stack status at any point, whether it is empty or whether it is full. If it is empty, we cannot pop any element out of it. If it is full, we cannot push any element on to it. We will of course, need to access the top element whenever somebody requires to pop an element out or whenever somebody requires to push an element on top. Let us discuss implementation of stack generically. To recapitulate, we will need to write the following function. First, initialize of course. It goes without saying that we will have to define the structure that we use to implement stack. After initializing it, we must have functions which will examine whether the stack is empty or stack is full. At any point in time, we must have access to the top element of the stack. And finally, the two important activities of either pushing an element on top of stack or popping an element out of stack. We will note that implementing stacks can be most easily done by two simple ways. Either we can use arrays or we can use linkless. Arrays are fixed size structure and therefore, they will impose a limit on the number of elements that you can put in to the stack. An array is indexed and therefore, we can access elements with an index starting with 0, 1, 2, 3, 5 up to the size. What we will do is, we will keep treating the array as if it were a stack and at any point in time, we will access only one element of the stack which is at the top or one element of the array which is at the top. Linkless provides a more generic mechanism because it has no limit on the size of the stack. Why? Because I can create a node in a linkless on the fly dynamically and I can keep on adding as many nodes as I wish to increase the size of the stack as per requirements. In the subsequent sessions, we shall see the implementation of a stack using an array and then implementing a stack using a linkless. Thank you.