An algorithm is a set of instructions given to a computer to solve a problem.  It requires an input which is then processed to produce the desired output. 

For eg:-

Step 1:-  Start

Step 2:- define x,y,z , 2,3 = input, z = output

Step 3:- multiply x and y , 6.

Step 4:- print z

Step 5:-  result = z= 6

No

Because c±± is statistically typed making the coding faster while python is dynamically typed, sometimes requiring interpreter making the coding slower

static variable life time will be during entire program time from starting the program to end of program .

suppose we have a function func() with two variables static variable x and simple variable y.

void func(){

static int x;

int  y;

}

dafult value of static variable is 0 , so initial value of x=0.

suppose we call function func() three times,

each time new y will be created on different memory places and y will have garbage value initially

but a single x will remain during all three function func() calls and  x will be created before function func() calls

just after running the program .

suppose we do not call function func() then y will not be created but x will be created with value 0.

A structure in C, is a collection of variables of different of same or different data type. When we declare a structure, we must also declare variables within that structure, for example if we create an employee structure, we must declare what variables do we want inside the employee structure I.e empid,name,salary etc. syntax: struct structure_name { datatype var1, datatype var2, . . . data type varn }; structurename var; struct is a keyword and must be used to declare a structure eg: struct employee { int empire, char name[20], float salary } employee e1; e1 is a structure variable of type employee which is a structure created. empid, name and salary are variables that will be created once e1 is created.

1.  There is no need to allocate contiguous memory locations in the linked list where as an array requires contiguous memory locations. 

2.  In an array,  memory is pre-allocated. Memory is allocated to maximum size even a few memory is used. 

     In linked list,  memory is allocated as much you want.

3.   Size con't be change at runtime in array . In linked list,  size can be shrink or expand. 

4.   Insertions and deletions are easy in linked list where as shifting of elements is required to insertion or deletion of an element in an array. 

Linear queue :

          Linear queue is a data structure in which insertions take place at one end and deletions take place at another end. There are two pointers FRONT and REAR. FRONT points to front element to be deleted. REAR points to last element  (newly inserted element ).

           There are two situations arise in the queue. UNDERFLOW arise when the user tries  to delete an element but queue is empty. OVERFLOW occurs when the user tries to insert an element but queue is full. 

          One limitation of the queue is that user tries to insert an element but queue shows OVERFLOW even though there are empty places in the queue as follows. 

                                         front 

                                         ⬆

              ⬜    ⬜    ⬜    ⬜    ⬜    ⬜     ⬜

                                         5      3       7        4

                                                                     ⬇

                                                                   rear

Circular queue :

         One solution for  the limitation of linear queue is circular queue in which last element is connecting back to first element. So,  queue shows OVERFLOW only when queue is really full. 

In any loop,  break is encountered the control immediately goes to the out of the loop and execute the statement following the loop. 

If continue is encountered in the loop,  then it skips the all the statements after continue statement and continue with next iteration. 

Array of pointers :

                Array of pointers points to sequential collection of addresses which points to addresses of the other variables. 

         Syntax of the array of pointers is 

                               Data Type    * ptr [ index ];

Example:

          1)   int  * p1[ 5 ];

              Memory representation is as follows 

   Ptr:                 p1[0]        p1[1]        p1 [2]        p1 [3]         p1[4]

    Address :       1000         2000         3000        4000         5000

Address :        1000        2000        3000        4000       5000

Variable :         5               20            15              10          30

Trees and graphs are non-linear data structures. 

A LIFO is technically called "stack ".