Recursion
Computer Science, GATE

Recursion Using C

In c, it is possible for functions to call themselves. A function calling itself is called as recursion sometimes called as ‘circular definition’. It is the process of defining something in terms of itself.

void abc()
{
abc(); //Function abc is calling itself again and again this is recursion
}

int main()
{
abc();
}



Recursion is used in problems like TowerofHanoi, tree traversal like Inorder,Preorder,Postorder etc.

Lets take an example which uses recursion. The example below is classical example for understanding the concept of recursion.

#include<stdio.h>
#include<conio.h>
long rec(int x);
int main()
{
long Factorial=1;
int number=1;
printf(“Enter No. to Find Factorial\n”);
scanf(“%d”,&number);
Factorial=rec(number);
printf(“Factorial of %d is %ld\n”,number,Factorial);
return 0;
}
long rec(int x) //Recursive function for calculating factorial
{
int f
if(x==1)
return 1;
else
f=x*rec(x-1); //Here function calling itself
return f;
}

Understanding above Code

This program can be understood as follow for number = 3.

Recursion

When we call function rec for x=3 it check is x equal to 1 no so it goes to else part and perform 3*rec(3-1). Now rec is again called for x=2 it again checks is is equal to 1 no so it goes to else part and perform 2*rec(2-1).Again rec is called for x=1 and finally here x is equal to 1 so it return 0 to the last function i.e., rec(2-1) becomes 1 and then multiply 2 to it goes to last function call i.e., rec(3-1) and it performs 3*2 = 6 and return it to main() hence function terminates here.

So we have seen here how a function call itself again and again untill a terminating condition is met here that condition is x equal to 1 or not once x becomes equal to 1 it backtracks to last function call.



Recursion uses stack because here the function which was called first was executed at the end i.e., in FIRST IN LAST OUT manner.

For More on Computer Science Click Here..!!

Sorting
Computer Science, GATE

Sorting Algorithms Time Complexities

Below is a table for time complexities of all the sorting algorithms that can be used as last minute revision notes for competitive exams as well as for placements. Time complexities of algorithms in best case, average case and worst case have been listed below.

Sorting AlgorithmsBest Case ComplexityAverage Case ComplexityWorst Case Complexity
Bubble SortΩ(n)θ(n^2)O(n^2)
Selection SortΩ(n^2)θ(n^2)O(n^2)
Insertion SortΩ(n)θ(n^2)O(n^2)
Merge SortΩ(nlogn)θ(nlogn)O(nlogn)
Quick SortΩ(nlogn)θ(nlogn)O(n^2)
Radix SortΩ(nk)θ(nk)O(nk)
Bucket SortΩ(n+k)θ(n+k)O(n^2)
Heap SortΩ(nlogn)θ(nlogn)O(nlogn)
Counting SortΩ(n+k)θ(n+k)O(n+k)



If you find any information mentioned above to be incorrect then please let us know in the comment box below.

For GATE CSE last revision notes Click Here..!!