UNIT 3

Array

3.1 Arrays Introduction

Arrays a kind of data structure that can store a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables. A specific element in an array is accessed by an index.

All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.

Declaring Arrays

To declare an array in C, a programmer specifies the type of the elements and the number of elements required by an array as follows −

Type arrayName [ arraySize ];

This is called a single-dimensional array. The arraySize must be an integer constant greater than zero and type can be any valid C data type. For example, to declare a 10-element array called balance of type double, use this statement −

Double balance[10];

Here balance is a variable array which is sufficient to hold up to 10 double numbers.

Initializing Arrays

You can initialize an array in C either one by one or using a single statement as follows −

Double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

The number of values between braces { } cannot be larger than the number of elements that we declare for the array between square brackets [ ].

If you omit the size of the array, an array just big enough to hold the initialization is created. Therefore, if you write −

Double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

You will create exactly the same array as you did in the previous example. Following is an example to assign a single element of the array −

Balance[4] = 50.0;

The above statement assigns the 5th element in the array with a value of 50.0. All arrays have 0 as the index of their first element which is also called the base index and the last index of an array will be total size of the array minus 1. Shown below is the pictorial representation of the array we discussed above −

Accessing Array Elements

An element is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example −

Double salary = balance[9];

The above statement will take the 10th element from the array and assign the value to salary variable. The following example Shows how to use all the three above mentioned concepts viz. Declaration, assignment, and accessing arrays −

#include <stdio.h>

Int main () {

Int n[ 10 ]; /* n is an array of 10 integers */

Int i,j;

/* initialize elements of array n to 0 */        

For ( i = 0; i < 10; i++ ) {

n[ i ] = i + 100; /* set element at location i to i + 100 */

}

/* output each array element's value */

For (j = 0; j < 10; j++ ) {

Printf("Element[%d] = %d\n", j, n[j] );

}

Return 0;

}

When the above code is compiled and executed, it produces the following result −

Element[0] = 100

Element[1] = 101

Element[2] = 102

Element[3] = 103

Element[4] = 104

Element[5] = 105

Element[6] = 106

Element[7] = 107

Element[8] = 108

Element[9] = 109

Arrays in Detail

Arrays are important to C and should need a lot more attention. The following important concepts related to array should be clear to a C programmer −

3.2 Array declaration and initialization

C Array

An array is defined as the collection of similar type of data items stored at contiguous memory locations. Arrays are the derived data type in C programming language which can store the primitive type of data such as int, char, double, float, etc. It also has the capability to store the collection of derived data types, such as pointers, structure, etc. The array is the simplest data structure where each data element can be randomly accessed by using its index number.

C array is beneficial if you have to store similar elements. For example, if we want to store the marks of a student in 6 subjects, then we don't need to define different variables for the marks in the different subject. Instead of that, we can define an array which can store the marks in each subject at the contiguous memory locations.

By using the array, we can access the elements easily. Only a few lines of code are required to access the elements of the array.

Properties of Array

The array contains the following properties.

• Each element of an array is of same data type and carries the same size, i.e., int = 4 bytes.
• Elements of the array are stored at contiguous memory locations where the first element is stored at the smallest memory location.
• Elements of the array can be randomly accessed since we can calculate the address of each element of the array with the given base address and the size of the data element.

Advantage of C Array

1) Code Optimization: Less code to the access the data.

2) Ease of traversing: By using the for loop, we can retrieve the elements of an array easily.

3) Ease of sorting: To sort the elements of the array, we need a few lines of code only.

4) Random Access: We can access any element randomly using the array.

Disadvantage of C Array

1) Fixed Size: Whatever size, we define at the time of declaration of the array, we can't exceed the limit. So, it doesn't grow the size dynamically like LinkedList which we will learn later.

Declaration of C Array

We can declare an array in the c language in the following way.

1. Data_type array_name[array_size];  

Now, let us see the example to declare the array.

1. Int marks[5];  

Here, int is the data_type, marks are the array_name, and 5 is the array_size.

Initialization of C Array

The simplest way to initialize an array is by using the index of each element. We can initialize each element of the array by using the index. Consider the following example.

1. Marks[0]=80;//initialization of array  
2. Marks[1]=60;  
3. Marks[2]=70;  
4. Marks[3]=85;  
5. Marks[4]=75;  

C array example

1. #include<stdio.h>  
2. Int main(){      
3. Int i=0;    
4. Int marks[5];//declaration of array       
5. Marks[0]=80;//initialization of array    
6. Marks[1]=60;    
7. Marks[2]=70;    
8. Marks[3]=85;    
9. Marks[4]=75;    
10. //traversal of array    
11. For(i=0;i<5;i++){      
12. Printf("%d \n",marks[i]);    
13. }//end of for loop     
14. Return 0;  
15. }    

Output

80

60

70

85

75

C Array: Declaration with Initialization

We can initialize the c array at the time of declaration. Let's see the code.

1. Int marks[5]={20,30,40,50,60};  

In such case, there is no requirement to define the size. So it may also be written as the following code.

1. Int marks[]={20,30,40,50,60};  

Let's see the C program to declare and initialize the array in C.

1. #include<stdio.h>  
2. Int main(){      
3. Int i=0;    
4. Int marks[5]={20,30,40,50,60};//declaration and initialization of array    
5. //traversal of array    
6. For(i=0;i<5;i++){      
7. Printf("%d \n",marks[i]);    
8. }    
9. Return 0;  
10. }    

Output

20

30

40

50

60

C Array Example: Sorting an array

In the following program, we are using bubble sort method to sort the array in ascending order.

1. #include<stdio.h>    
2. Void main ()    
3. {    
4.    Int i, j,temp;     
5.    Int a[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};     
6.    For(i = 0; i<10; i++)    
7.    {    
8.        For(j = i+1; j<10; j++)    
9.        {    
10.            If(a[j] > a[i])    
11.            {    
12.                Temp = a[i];    
13.                a[i] = a[j];    
14.                a[j] = temp;     
15.            }     
16.        }     
17.    }     
18.    Printf("Printing Sorted Element List ...\n");    
19.    For(i = 0; i<10; i++)    
20.    {    
21.        Printf("%d\n",a[i]);    
22.    }    
23. }     

Program to print the largest and second largest element of the array.

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Int arr[100],i,n,largest,sec_largest;  
5.    Printf("Enter the size of the array?");  
6.    Scanf("%d",&n);  
7.    Printf("Enter the elements of the array?");  
8.    For(i = 0; i<n; i++)  
9.    {  
10.        Scanf("%d",&arr[i]);  
11.    }  
12.    Largest = arr[0];  
13.    Sec_largest = arr[1];  
14.    For(i=0;i<n;i++)  
15.    {  
16.        If(arr[i]>largest)  
17.        {  
18.            Sec_largest = largest;  
19.            Largest = arr[i];  
20.        }  
21.        Else if (arr[i]>sec_largest && arr[i]!=largest)  
22.        {  
23.            Sec_largest=arr[i];  
24.        }  
25.    }  
26.    Printf("largest = %d, second largest = %d",largest,sec_largest);  
27.      
28. }  

3.3 Array types: one dimensional, two dimensional arrays

One-dimensional array

Conceptually you can think of a one-dimensional array as a row, where elements are stored one after another.

Syntax: datatype array_name[size];

Datatype: It denotes the type of the elements in the array.

Array_name: Name of the array. It must be a valid identifier.

Size: Number of elements an array can hold. Here are some example of array declarations:

Num is an array of type int, which can only store 100 elements of type int.
temp is an array of type float, which can only store 20 elements of type float.
ch is an array of type char, which can only store 50 elements of type char.

Note: When an array is declared it contains garbage values.

The individual elements in the array:

We can also use variables and symbolic constants to specify the size of the array.

Note: Until C99 standard, we were not allowed to use variables to specify the size of the array. If you are using a compiler which supports C99 standard, the above code would compile successfully. However, If you're using an older version of C compiler like Turbo C++, then you will get an error.

The use of symbolic constants makes the program maintainable, because later if you want to change the size of the array you need to modify it at once place only i.e in the #define directive.

Accessing elements of an array

The elements of an array can be accessed by specifying array name followed by subscript or index inside square brackets (i.e []). Array subscript or index starts at 0. If the size of an array is 10 then the first element is at index 0, while the last element is at index 9. The first valid subscript (i.e 0) is known as the lower bound, while last valid subscript is known as the upper bound.

Int my_arr[5];

Then elements of this array are;

First element – my_arr[0]
Second element – my_arr[1]
Third element – my_arr[2]
Fourth element – my_arr[3]
Fifth element – my_arr[4]

Array subscript or index can be any expression that yields an integer value. For example:

In the array my_arr, the last element is at my_arr[4], What if you try to access elements beyond the last valid index of the array?

Sure indexes 5, 10 and -1 are not valid but C compiler will not show any error message instead some garbage value will be printed. The C language doesn't check bounds of the array. It is the responsibility of the programmer to check array bounds whenever required.

Processing 1-D arrays

The following program uses for loop to take input and print elements of a 1-D array.

Expected Output:

How it works:

In Line 5, we have declared an array of 5 integers and variable i of type int. Then a for loop is used to enter five elements into an array. In scanf() we have used & operator (also known as the address of operator) on element arr[i] of an array, just like we had done with variables of type int, float, char etc. Line 13 prints "Printing elements of the array" to the console. The second for loop prints all the elements of an array one by one.

The following program prints the sum of elements of an array.

Expected Output:

How it works: The first for loop asks the user to enter five elements into the array. The second for loop reads all the elements of an array one by one and accumulate the sum of all the elements in the variable s. Note that it is necessary to initialize the variable s to 0, otherwise, we will get the wrong answer because of the garbage value of s.

Initializing Array

When an array is declared inside a function the elements of the array have garbage value. If an array is global or static, then its elements are automatically initialized to 0. We can explicitly initialize elements of an array at the time of declaration using the following syntax:

Syntax: datatype array_name[size] = { val1, val2, val3, ..... ValN };

Datatype is the type of elements of an array.

Array_name is the variable name, which must be any valid identifier.

Size is the size of the array.

Val1, val2 ... Are the constants known as initializers. Each value is separated by a comma(,) and then there is a semi-colon (;) after the closing curly brace (}).

Here is are some examples:

While initializing 1-D array it is optional to specify the size of the array, so you can also write the above statements as:

If the number of initializers is less than the specified size then the remaining elements of the array are assigned a value of 0.

Float temp[5] = {12.3, 4.1};

Here the size of temp array is 5 but there are only two initializers. After this initialization the elements of the array are as follows:

Temp[0] is 12.3
temp[1] is 4.1
temp[2] is 0
temp[3] is 0
temp[4] is 0

If the number of initializers is greater than the size of the array then, the compiler will report an error. For example:

Int num[5] = {1, 2, 3, 4, 5, 6, 7, 8} // error

The following program finds the highest and lowest elements in an array.

Expected Output:

How it works: In line 6, first, we have declared and initialized an array of 10 integers. In the next line, we have declared three more variables of type int namely: i, max and min. In line 9, we have assigned the value of the first element of my_arr to max and min. A for loop is used to iterate through all the elements of an array. Inside the for loop, the first if condition (my_arr[i] > max) checks whether the current element is greater than max, if it is, we assign the value of the current element to max.

The second if statement checks whether the value of the current element is smaller than the value of min. If it is, we assign the value of the current element to min. This process continues until there are elements in the array left to iterate.

When the process is finished, max and min variables will have maximum and minimum values respectively.

Two Dimensional Array in C

The two-dimensional array can be defined as an array of arrays. The 2D array is organized as matrices which can be represented as the collection of rows and columns. However, 2D arrays are created to implement a relational database lookalike data structure. It provides ease of holding the bulk of data at once which can be passed to any number of functions wherever required.

Declaration of two dimensional Array in C

The syntax to declare the 2D array is given below.

1. Data_type array_name[rows][columns];  

Consider the following example.

1. Int twodimen[4][3];  

Here, 4 is the number of rows, and 3 is the number of columns.

Initialization of 2D Array in C

In the 1D array, we don't need to specify the size of the array if the declaration and initialization are being done simultaneously. However, this will not work with 2D arrays. We will have to define at least the second dimension of the array. The two-dimensional array can be declared and defined in the following way.

1. Int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};  

Two-dimensional array example in C

1. #include<stdio.h>  
2. Int main(){      
3. Int i=0,j=0;    
4. Int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};     
5. //traversing 2D array    
6. For(i=0;i<4;i++){    
7. For(j=0;j<3;j++){    
8.   Printf("arr[%d] [%d] = %d \n",i,j,arr[i][j]);    
9. }//end of j    
10. }//end of i    
11. Return 0;  
12. }    

Output

Arr[0][0] = 1

Arr[0][1] = 2

Arr[0][2] = 3

Arr[1][0] = 2

Arr[1][1] = 3

Arr[1][2] = 4

Arr[2][0] = 3

Arr[2][1] = 4

Arr[2][2] = 5

Arr[3][0] = 4

Arr[3][1] = 5

Arr[3][2] = 6

C 2D array example: Storing elements in a matrix and printing it.

1. #include <stdio.h>    
2. Void main ()    
3. {    
4.    Int arr[3][3],i,j;     
5.    For (i=0;i<3;i++)    
6.    {    
7.        For (j=0;j<3;j++)    
8.        {    
9.            Printf("Enter a[%d][%d]: ",i,j);                
10.            Scanf("%d",&arr[i][j]);    
11.        }    
12.    }    
13.    Printf("\n printing the elements ....\n");     
14.    For(i=0;i<3;i++)    
15.    {    
16.        Printf("\n");    
17.        For (j=0;j<3;j++)    
18.        {    
19.            Printf("%d\t",arr[i][j]);    
20.        }    
21.    }    
22. }    

Output

Enter a[0][0]: 56  

Enter a[0][1]: 10  

Enter a[0][2]: 30 

Enter a[1][0]: 34 

Enter a[1][1]: 21

Enter a[1][2]: 34   

Enter a[2][0]: 45

Enter a[2][1]: 56

Enter a[2][2]: 78  

Printing the elements ....

56      10      30 

34      21      34 

45      56      78

3.4 Bubble sort

In Bubble sort, Each element of the array is compared with its adjacent element. The algorithm processes the list in passes. A list with n elements requires n-1 passes for sorting. Consider an array A of n elements whose elements are to be sorted by using Bubble sort. The algorithm processes like following.

1. In Pass 1, A[0] is compared with A[1], A[1] is compared with A[2], A[2] is compared with A[3] and so on. At the end of pass 1, the largest element of the list is placed at the highest index of the list.
2. In Pass 2, A[0] is compared with A[1], A[1] is compared with A[2] and so on. At the end of Pass 2 the second largest element of the list is placed at the second highest index of the list.
3. In pass n-1, A[0] is compared with A[1], A[1] is compared with A[2] and so on. At the end of this pass. The smallest element of the list is placed at the first index of the list.

Algorithm :

• Step 1: Repeat Step 2 For i = 0 to N-1
• Step 2: Repeat For J = i + 1 to N - I
• Step 3: IF A[J] > A[i]
  SWAP A[J] and A[i]
  [END OF INNER LOOP]
  [END OF OUTER LOOP
• Step 4: EXIT

Complexity

C Program

1. #include<stdio.h>  
2. Void main ()  
3. {  
4.    Int i, j,temp;   
5.    Int a[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};   
6.    For(i = 0; i<10; i++)  
7.    {  
8.        For(j = i+1; j<10; j++)  
9.        {  
10.            If(a[j] > a[i])  
11.            {  
12.                Temp = a[i];  
13.                a[i] = a[j];  
14.                a[j] = temp;   
15.            }   
16.        }   
17.    }   
18.    Printf("Printing Sorted Element List ...\n");  
19.    For(i = 0; i<10; i++)  
20.    {  
21.        Printf("%d\n",a[i]);  
22.    }  
23. }  

Output:

Printing Sorted Element List . . .

7

9

10

12

23

34

34

44

78

101

C++ Program

1. #include<iostream>  
2. Using namespace std;  
3. Int main ()  
4. {  
5.    Int i, j,temp;   
6.    Int a[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};   
7.    For(i = 0; i<10; i++)  
8.    {  
9.        For(j = i+1; j<10; j++)  
10.        {  
11.            If(a[j] < a[i])  
12.            {  
13.                Temp = a[i];  
14.                a[i] = a[j];  
15.                a[j] = temp;   
16.            }   
17.        }   
18.    }   
19.    Cout <<"Printing Sorted Element List ...\n";  
20.    For(i = 0; i<10; i++)  
21.    {  
22.        Cout <<a[i]<<"\n";  
23.    }  
24.    Return 0;  
25. }  

Output:

Printing Sorted Element List ...

7

9

10

12

23

23

34

44

78

101

Java Program

1. Public class BubbleSort {  
2.    Public static void main(String[] args) {  
3.    Int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};  
4.    For(int i=0;i<10;i++)  
5.    {  
6.        For (int j=0;j<10;j++)  
7.        {  
8.            If(a[i]<a[j])  
9.            {  
10.                Int temp = a[i];  
11.                a[i]=a[j];  
12.                a[j] = temp;   
13.            }  
14.        }  
15.    }  
16.    System.out.println("Printing Sorted List ...");  
17.    For(int i=0;i<10;i++)  
18.    {  
19.        System.out.println(a[i]);  
20.    }  
21. }  
22. }  

Output:

Printing Sorted List . . .

7

9

10

12

23

34

34

44

78

101

C# Program

1. Using System;  
2.                      
3. Public class Program  
4. {  
5.    Public static void Main()  
6.    {  
7.        Int i, j,temp;   
8.    Int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};   
9.    For(i = 0; i<10; i++)  
10.    {  
11.        For(j = i+1; j<10; j++)  
12.        {  
13.            If(a[j] > a[i])  
14.            {  
15.                Temp = a[i];  
16.                a[i] = a[j];  
17.                a[j] = temp;   
18.            }   
19.        }   
20.    }   
21.    Console.WriteLine("Printing Sorted Element List ...\n");  
22.    For(i = 0; i<10; i++)  
23.    {  
24.        Console.WriteLine(a[i]);  
25.    }  
26.    }  
27. }  

Output:

Printing Sorted Element List . . .

7

9

10

12

23

34

34

44

78

101

Python Program

1. a=[10, 9, 7, 101, 23, 44, 12, 78, 34, 23]  
2. For i in range(0,len(a)):  
3.    For j in range(i+1,len(a)):  
4.        If a[j]<a[i]:  
5.            Temp = a[j]  
6.            a[j]=a[i]  
7.            a[i]=temp  
8. Print("Printing Sorted Element List...")  
9. For i in a:   
10.    Print(i)  

Output:

Printing Sorted Element List . . .

7

9

10

12

23

34

34

44

78

101

Rust Program

1. Fn main()  
2. {  
3.    Let mut temp;  
4. Let mut a: [i32; 10] = [10, 9, 7, 101, 23, 44, 12, 78, 34, 23];  
5.    For i in 0..10  
6.    {  
7.        For j in (i+1)..10  
8.        {  
9.            If a[j] < a[i]  
10.            {  
11.                Temp = a[i];  
12.                a[i] = a[j];  
13.                a[j] = temp;   
14.            }  
15.        }   
16.    }   
17.    Println!("Printing Sorted Element List ...\n");  
18.    For i in &a  
19.    {  
20.        Println!("{} ",i);  
21.    }  
22. }  

Output:

Printing Sorted Element List . . .

7

9

10

12

23

34

34

44

78

101

4

JavaScript Program

1. <html>  
2. <head>  
3. <title>   
4. Bubble Sort   
5. </title>   
6. </head>   
7. <body>  
8. <script>   
9.    Var a = [10, 9, 7, 101, 23, 44, 12, 78, 34, 23];  
10.    For(i=0;i<10;i++)  
11.    {  
12.        For (j=0;j<10;j++)  
13.        {  
14.            If(a[i]<a[j])  
15.            {  
16.                 Temp = a[i];  
17.                a[i]=a[j];  
18.                a[j] = temp;   
19.            }  
20.        }  
21.    }  
22.    Txt = "<br>";  
23.    Document.writeln("Printing Sorted Element List ..."+txt);  
24.    For(i=0;i<10;i++)  
25.    {  
26.        Document.writeln(a[i]);  
27.        Document.writeln(txt);  
28.    }  
29.    </script>   
30.    </body>  
31. </html>  

Output:

Printing Sorted Element List ...

7

9

10

12

23

23

34

44

78

101

PHP Program

1. <html>  
2. <head>  
3. <title>Bubble Sort</title>  
4. </head>  
5. <body>  
6. <?php  
7.    $a = array(10, 9, 7, 101, 23, 44, 12, 78, 34, 23);  
8.    For($i=0;$i<10;$i++)  
9.    {  
10.        For ($j=0;$j<10;$j++)  
11.        {  
12.            If($a[$i]<$a[$j])  
13.            {  
14.                 $temp = $a[$i];  
15.                $a[$i]=$a[$j];  
16.                $a[$j] = $temp;   
17.            }  
18.        }  
19.    }  
20.    Echo "Printing Sorted Element List ...\n";  
21.    For($i=0;$i<10;$i++)  
22.    {  
23.        Echo $a[$i];  
24.        Echo "\n";  
25.    }  
26. ?>  
27. </body>  
28. </html>  

Output:

Printing Sorted Element List ...

7

9

10

12

23

23

34

44

78

101

3.5 Selection sort

In selection sort, the smallest value among the unsorted elements of the array is selected in every pass and inserted to its appropriate position into the array.

First, find the smallest element of the array and place it on the first position. Then, find the second smallest element of the array and place it on the second position. The process continues until we get the sorted array.

The array with n elements is sorted by using n-1 pass of selection sort algorithm.

• In 1st pass, smallest element of the array is to be found along with its index pos. Then, swap A[0] and A[pos]. Thus A[0] is sorted, we now have n -1 elements which are to be sorted.
• In 2nd pas, position pos of the smallest element present in the sub-array A[n-1] is found. Then, swap, A[1] and A[pos]. Thus A[0] and A[1] are sorted, we now left with n-2 unsorted elements.
• In n-1th pass, position pos of the smaller element between A[n-1] and A[n-2] is to be found. Then, swap, A[pos] and A[n-1].

Therefore, by following the above explained process, the elements A[0], A[1], A[2],...., A[n-1] are sorted.

Example

Consider the following array with 6 elements. Sort the elements of the array by using selection sort.

A = {10, 2, 3, 90, 43, 56}.

Sorted A = {2, 3, 10, 43, 56, 90}

Complexity

Algorithm

SELECTION SORT(ARR, N)

• Step 1: Repeat Steps 2 and 3 for K = 1 to N-1
• Step 2: CALL SMALLEST(ARR, K, N, POS)
• Step 3: SWAP A[K] with ARR[POS]
  [END OF LOOP]
• Step 4: EXIT

SMALLEST (ARR, K, N, POS)

• Step 1: [INITIALIZE] SET SMALL = ARR[K]
• Step 2: [INITIALIZE] SET POS = K
• Step 3: Repeat for J = K+1 to N -1
  IF SMALL > ARR[J]
  SET SMALL = ARR[J]
  SET POS = J
  [END OF IF]
  [END OF LOOP]
• Step 4: RETURN POS

C Program

1. #include<stdio.h>  
2. Int smallest(int[],int,int);  
3. Void main ()  
4. {  
5.    Int a[10] = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};  
6.    Int i,j,k,pos,temp;  
7.    For(i=0;i<10;i++)  
8.    {  
9.        Pos = smallest(a,10,i);  
10.        Temp = a[i];  
11.        a[i]=a[pos];  
12.        a[pos] = temp;  
13.    }  
14.    Printf("\nprinting sorted elements...\n");  
15.    For(i=0;i<10;i++)  
16.    {  
17.        Printf("%d\n",a[i]);  
18.    }  
19. }  
20. Int smallest(int a[], int n, int i)  
21. {  
22.    Int small,pos,j;  
23.    Small = a[i];  
24.    Pos = i;  
25.    For(j=i+1;j<10;j++)  
26.    {  
27.        If(a[j]<small)  
28.        {  
29.            Small = a[j];  
30.            Pos=j;  
31.        }  
32.    }  
33.    Return pos;  
34. }  

Output:

Printing sorted elements...

7

9

10

12

23

23

34

44

78

101

C++ Program

1. #include<iostream>  
2. Using namespace std;  
3. Int smallest(int[],int,int);  
4. Int main ()  
5. {  
6.    Int a[10] = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};  
7.    Int i,j,k,pos,temp;  
8.    For(i=0;i<10;i++)  
9.    {  
10.        Pos = smallest(a,10,i);  
11.        Temp = a[i];  
12.        a[i]=a[pos];  
13.        a[pos] = temp;  
14.    }  
15.    Cout<<"\n printing sorted elements...\n";  
16.    For(i=0;i<10;i++)  
17.    {  
18.        Cout<<a[i]<<"\n";  
19.    }  
20.    Return 0;  
21. }  
22. Int smallest(int a[], int n, int i)  
23. {  
24.    Int small,pos,j;  
25.    Small = a[i];  
26.    Pos = i;  
27.    For(j=i+1;j<10;j++)  
28.    {  
29.        If(a[j]<small)  
30.        {  
31.            Small = a[j];  
32.            Pos=j;  
33.        }  
34.    }  
35.    Return pos;  
36. }  

Output:

Printing sorted elements...

7

9

10

12

23

23

34

44

78

101

Java Program

1. Public class SelectionSort {  
2. Public static void main(String[] args) {  
3.    Int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};  
4.    Int i,j,k,pos,temp;  
5.    For(i=0;i<10;i++)  
6.    {  
7.        Pos = smallest(a,10,i);  
8.        Temp = a[i];  
9.        a[i]=a[pos];  
10.        a[pos] = temp;  
11.    }  
12.    System.out.println("\nprinting sorted elements...\n");  
13.    For(i=0;i<10;i++)  
14.    {  
15.        System.out.println(a[i]);  
16.    }  
17. }  
18. Public static int smallest(int a[], int n, int i)  
19. {  
20.    Int small,pos,j;  
21.    Small = a[i];  
22.    Pos = i;  
23.    For(j=i+1;j<10;j++)  
24.    {  
25.        If(a[j]<small)  
26.        {  
27.            Small = a[j];  
28.            Pos=j;  
29.        }  
30.    }  
31.    Return pos;  
32. }  
33. }  

Output:

Printing sorted elements...

7

9

10

12

23

23

34

44

78

101

C# Program

1. Using System;                 
2. Public class Program  
3. {  
4.      
5.      
6. Public void Main() {  
7.    Int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};  
8.    Int i,pos,temp;  
9.    For(i=0;i<10;i++)  
10.    {  
11.        Pos = smallest(a,10,i);  
12.        Temp = a[i];  
13.        a[i]=a[pos];  
14.        a[pos] = temp;  
15.    }  
16.    Console.WriteLine("\nprinting sorted elements...\n");  
17.    For(i=0;i<10;i++)  
18.    {  
19.        Console.WriteLine(a[i]);  
20.    }  
21. }  
22. Public static int smallest(int[] a, int n, int i)  
23. {  
24.    Int small,pos,j;  
25.    Small = a[i];  
26.    Pos = i;  
27.    For(j=i+1;j<10;j++)  
28.    {  
29.        If(a[j]<small)  
30.        {  
31.            Small = a[j];  
32.            Pos=j;  
33.        }  
34.    }  
35.    Return pos;  
36. }  
37. }  

Output:

Printing sorted elements...

7

9

10

12

23

23

34

44

78

101

Python Program

1. Def smallest(a,i):  
2.    Small = a[i]  
3.    Pos=i  
4.    For j in range(i+1,10):  
5.        If a[j] < small:  
6.            Small = a[j]   
7.            Pos = j   
8.    Return pos   
9.      
10. a=[10, 9, 7, 101, 23, 44, 12, 78, 34, 23]  
11. For i in range(0,10):  
12.    Pos = smallest(a,i)  
13.    Temp = a[i]  
14.    a[i]=a[pos]  
15.    a[pos]=temp  
16. Print("printing sorted elements...")  
17. For i in a:  
18.    Print(i)  

Output:

Printing sorted elements...

7

9

10

12

23

23

34

44

78

101

Rust Program

1. Fn main ()  
2. {  
3.    Let mut a: [i32;10] = [10, 9, 7, 101, 23, 44, 12, 78, 34, 23];  
4.      
5.    For i in 0..10  
6.    {  
7.        Let mut small = a[i];  
8.        Let mut pos = i;  
9.        For j in (i+1)..10  
10.        {  
11.        If a[j]<small  
12.        {  
13.            Small = a[j];  
14.            Pos=j;  
15.        }  
16.    }  
17.        Let mut temp = a[i];  
18.        a[i]=a[pos];  
19.        a[pos] = temp;  
20.    }  
21.    Println!("\nprinting sorted elements...\n");  
22.    For i in &a  
23.    {  
24.        Println!("{}",i);  
25.    }  
26. }   

Output:

Printing sorted elements...

7

9

10

12

23

23

34

44

78

101

JavaScript Program

1. <html>  
2. <head>  
3. <title>   
4.    Selection Sort   
5. </title>   
6.    </head>  
7.    <body>   
8.    <script>  
9. Function smallest(a,  n, i)  
10. {  
11.      
12.    Var small = a[i];  
13.    Var pos = i;  
14.    For(j=i+1;j<10;j++)  
15.    {  
16.        If(a[j]<small)  
17.        {  
18.            Small = a[j];  
19.            Pos=j;  
20.        }  
21.    }  
22.    Return pos;  
23. }  
24. Var a = [10, 9, 7, 101, 23, 44, 12, 78, 34, 23];  
25.    For(i=0;i<10;i++)  
26.    {  
27.        Pos = smallest(a,10,i);  
28.        Temp = a[i];  
29.        a[i]=a[pos];  
30.        a[pos] = temp;  
31.    }  
32.    Document.writeln("printing sorted elements ...\n"+"<br>");  
33.    For(i=0;i<10;i++)  
34.    {  
35.        Document.writeln(a[i]+"<br>");  
36.    }  
37.        </script>  
38.    </body>  
39. </html>  

Output:

Printing sorted elements ...

7

9

10

12

23

23

34

44

78

101

PHP Program

1. <html>  
2. <head>  
3. <title>Selection sort</title>  
4. </head>  
5. <body>  
6. <?php  
7. Function smallest($a,  $n, $i)  
8. {  
9.      
10.    $small = $a[$i];  
11.    $pos = $i;  
12.    For($j=$i+1;$j<10;$j++)  
13.    {  
14.        If($a[$j]<$small)  
15.        {  
16.            $small = $a[$j];  
17.            $pos=$j;  
18.        }  
19.    }  
20.    Return $pos;  
21. }  
22. $a = array(10, 9, 7, 101, 23, 44, 12, 78, 34, 23);  
23.    For($i=0;$i<10;$i++)  
24.    {  
25.        $pos = smallest($a,10,$i);  
26.        $temp = $a[$i];  
27.        $a[$i]=$a[$pos];  
28.        $a[$pos] = $temp;  
29.    }  
30.    Echo "printing sorted elements ...\n";  
31.    For($i=0;$i<10;$i++)  
32.    {  
33.        Echo $a[$i];  
34.        Echo "\n";  
35.    }  
36. ?>  
37. </body>  
38. </html>  

Output:

Printing sorted elements ...

7

9

10

12

23

23

34

44

78

101

3.6 Functions: Introduction

C Functions

In c, we can divide a large program into the basic building blocks known as function. The function contains the set of programming statements enclosed by {}. A function can be called multiple times to provide reusability and modularity to the C program. In other words, we can say that the collection of functions creates a program. The function is also known as procedure or subroutine in other programming languages.

Advantage of functions in C

There are the following advantages of C functions.

• By using functions, we can avoid rewriting same logic/code again and again in a program.
• We can call C functions any number of times in a program and from any place in a program.
• We can track a large C program easily when it is divided into multiple functions.
• Reusability is the main achievement of C functions.
• However, Function calling is always a overhead in a C program.

Function Aspects

There are three aspects of a C function.

• Function declaration A function must be declared globally in a c program to tell the compiler about the function name, function parameters, and return type.

• Function call Function can be called from anywhere in the program. The parameter list must not differ in function calling and function declaration. We must pass the same number of functions as it is declared in the function declaration.

• Function definition It contains the actual statements which are to be executed. It is the most important aspect to which the control comes when the function is called. Here, we must notice that only one value can be returned from the function.

The syntax of creating function in c language is given below:

1. Return_type function_name(data_type parameter...){  
2. //code to be executed  
3. }  

Types of Functions

There are two types of functions in C programming:

1. Library Functions: are the functions which are declared in the C header files such as scanf(), printf(), gets(), puts(), ceil(), floor() etc.
2. User-defined functions: are the functions which are created by the C programmer, so that he/she can use it many times. It reduces the complexity of a big program and optimizes the code.

Return Value

A C function may or may not return a value from the function. If you don't have to return any value from the function, use void for the return type.

Let's see a simple example of C function that doesn't return any value from the function.

Example without return value:

1. Void hello(){  
2. Printf("hello c");  
3. }  

If you want to return any value from the function, you need to use any data type such as int, long, char, etc. The return type depends on the value to be returned from the function.

Let's see a simple example of C function that returns int value from the function.

Example with return value:

1. Int get(){  
2. Return 10;  
3. }  

In the above example, we have to return 10 as a value, so the return type is int. If you want to return floating-point value (e.g., 10.2, 3.1, 54.5, etc), you need to use float as the return type of the method.

1. Float get(){  
2. Return 10.2;  
3. }  

Now, you need to call the function, to get the value of the function.

Different aspects of function calling

A function may or may not accept any argument. It may or may not return any value. Based on these facts, There are four different aspects of function calls.

• Function without arguments and without return value
• Function without arguments and with return value
• Function with arguments and without return value
• Function with arguments and with return value

Example for Function without argument and return value

Example 1

1. #include<stdio.h>  
2. Void printName();  
3. Void main ()  
4. {  
5.    Printf("Hello ");  
6.    PrintName();  
7. }  
8. Void printName()  
9. {  
10.    Printf("Javatpoint");  
11. }  

Output

Hello Javatpoint

Example 2

1. #include<stdio.h>  
2. Void sum();  
3. Void main()  
4. {  
5.    Printf("\nGoing to calculate the sum of two numbers:");  
6.    Sum();  
7. }  
8. Void sum()  
9. {  
10.    Int a,b;   
11.    Printf("\nEnter two numbers");  
12.    Scanf("%d %d",&a,&b);   
13.    Printf("The sum is %d",a+b);  
14. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example for Function without argument and with return value

Example 1

1. #include<stdio.h>  
2. Int sum();  
3. Void main()  
4. {  
5.    Int result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Result = sum();  
8.    Printf("%d",result);  
9. }  
10. Int sum()  
11. {  
12.    Int a,b;   
13.    Printf("\nEnter two numbers");  
14.    Scanf("%d %d",&a,&b);  
15.    Return a+b;   
16. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example 2: program to calculate the area of the square

1. #include<stdio.h>  
2. Int sum();  
3. Void main()  
4. {  
5.    Printf("Going to calculate the area of the square\n");  
6.    Float area = square();  
7.    Printf("The area of the square: %f\n",area);  
8. }  
9. Int square()  
10. {  
11.    Float side;  
12.    Printf("Enter the length of the side in meters: ");  
13.    Scanf("%f",&side);  
14.    Return side * side;  
15. }  

Output

Going to calculate the area of the square

Enter the length of the side in meters: 10

The area of the square: 100.000000

Example for Function with argument and without return value

Example 1

1. #include<stdio.h>  
2. Void sum(int, int);  
3. Void main()  
4. {  
5.    Int a,b,result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Printf("\nEnter two numbers:");  
8.    Scanf("%d %d",&a,&b);  
9.    Sum(a,b);  
10. }  
11. Void sum(int a, int b)  
12. {  
13.    Printf("\nThe sum is %d",a+b);      
14. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example 2: program to calculate the average of five numbers.

1. #include<stdio.h>  
2. Void average(int, int, int, int, int);  
3. Void main()  
4. {  
5.    Int a,b,c,d,e;   
6.    Printf("\nGoing to calculate the average of five numbers:");  
7.    Printf("\nEnter five numbers:");  
8.    Scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);  
9.    Average(a,b,c,d,e);  
10. }  
11. Void average(int a, int b, int c, int d, int e)  
12. {  
13.    Float avg;   
14.    Avg = (a+b+c+d+e)/5;   
15.    Printf("The average of given five numbers : %f",avg);  
16. }  

Output

Going to calculate the average of five numbers:

Enter five numbers:10

20

30

40

50

The average of given five numbers : 30.000000

Example for Function with argument and with return value

Example 1

1. #include<stdio.h>  
2. Int sum(int, int);  
3. Void main()  
4. {  
5.    Int a,b,result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Printf("\nEnter two numbers:");  
8.    Scanf("%d %d",&a,&b);  
9.    Result = sum(a,b);  
10.    Printf("\nThe sum is : %d",result);  
11. }  
12. Int sum(int a, int b)  
13. {  
14.    Return a+b;  
15. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers:10

20

The sum is : 30  

Example 2: Program to check whether a number is even or odd

1. #include<stdio.h>  
2. Int even_odd(int);  
3. Void main()  
4. {  
5. Int n,flag=0;  
6. Printf("\nGoing to check whether a number is even or odd");  
7. Printf("\nEnter the number: ");  
8. Scanf("%d",&n);  
9. Flag = even_odd(n);  
10. If(flag == 0)  
11. {  
12.    Printf("\nThe number is odd");  
13. }  
14. Else   
15. {  
16.    Printf("\nThe number is even");  
17. }  
18. }  
19. Int even_odd(int n)  
20. {  
21.    If(n%2 == 0)  
22.    {  
23.        Return 1;  
24.    }  
25.    Else   
26.    {  
27.        Return 0;  
28.    }  
29. }  

Output

Going to check whether a number is even or odd

Enter the number: 100

The number is even

C Library Functions

Library functions are the inbuilt function in C that are grouped and placed at a common place called the library. Such functions are used to perform some specific operations. For example, printf is a library function used to print on the console. The library functions are created by the designers of compilers. All C standard library functions are defined inside the different header files saved with the extension .h. We need to include these header files in our program to make use of the library functions defined in such header files. For example, To use the library functions such as printf/scanf we need to include stdio.h in our program which is a header file that contains all the library functions regarding standard input/output.

The list of mostly used header files is given in the following table.

3.7 Standard library function

C Standard library functions or simply C Library functions are inbuilt functions in C programming.

The prototype and data definitions of these functions are present in their respective header files. To use these functions we need to include the header file in our program. For example,

If you want to use the printf() function, the header file <stdio.h> should be included.

#include <stdio.h>

Int main()

{

Printf("Catch me if you can.");

}

If you try to use printf() without including the stdio.h header file, you will get an error.

Advantages of Using C library functions

1. They work

One of the most important reasons you should use library functions is simply because they work. These functions have gone through multiple rigorous testing and are easy to use.

2. The functions are optimized for performance

Since, the functions are "standard library" functions, a dedicated group of developers constantly make them better. In the process, they are able to create the most efficient code optimized for maximum performance.

3. It saves considerable development time

Since the general functions like printing to a screen, calculating the square root, and many more are already written. You shouldn't worry about creating them once again.

4. The functions are portable

With ever-changing real-world needs, your application is expected to work every time, everywhere. And, these library functions help you in that they do the same thing on every computer.

Example: Square root using sqrt() function

Suppose, you want to find the square root of a number.

To can compute the square root of a number, you can use the sqrt() library function. The function is defined in the math.h header file.

#include <stdio.h>

#include <math.h>

Int main()

{

Float num, root;

Printf("Enter a number: ");

Scanf("%f", &num);

// Computes the square root of num and stores in root.

Root = sqrt(num);

Printf("Square root of %.2f = %.2f", num, root);

Return 0;

}

When you run the program, the output will be:

Enter a number: 12

Square root of 12.00 = 3.46

Library Functions in Different Header Files

3.8 User define function: Declaration and definition

User-defined Functions

User can define functions to do a task relevant to their programs. Such functions are called user-defined functions. The main( ) function in which we write all our program is a user-defined function. Every pro0gram execution starts at the main( ) function.
Any function (library or user-defined) has 3 things

1. Function declaration
2. Function calling
3. Function defintion

In case of library functions, the function declaration is in header files. The function is library files and the calling is in the program. But in case of user-defined functions all the 3 things are in your source program. Function declaration:
Syntax:
return data_type function_name(arguments list);

Function Definition:
Syntax:
return data_type function_name(argument list)
{
Body;
}
Function Calling:
Syntax:
Function_name(param_list);
Formal Arguments:
The arguments which are given at the time of function declaration or function definition are called formal arguments.

Actual Arguments:
The arguments which are given at the time of function calling are called actual arguments.

General Form of a Function

Return data type  function-name(arglist)

Argument declaration

{

Local variable declaration;

Executable statements;

----------------

----------------

Return(expression);

}

All parts are not essential. Some may be absent.
For eg: The argument list and it’s associated argument declaration part are optional.
We may recall that the main functions discussed so far have not included any arguments.

return: This statement is for returning a value to the calling function. This is an optional statement. It’s absence indicates that no value is being return to the calling function.

Function name: A function must follow the same rules of formation as other variable names in C. Additional care must be taken to avoid duplicating library functions names or operating system commands.

Argument list : It contains valid variable name separated by commas. The list must be surrounded by parenthesis. Note that no semi colon follows the closing parenthesis. The argument variables receive values from the calling function. Thus providing a means of data communication from calling function to the called function.

If the arguments are present before beginning with the statements in the functions it is necessary to declare the type of arguments through the type declaration statements.

Note: There are two methods of declaring the parameters. The older method (known as "classic" method) declares function arguments separately after the definition of function name (known as function header).

The newer method (known as "modern" or ANSI method) combines the function definition and argument declaration in one line. Luckily the modern compilers support both the methods. That is, we can write a function using either of them and execute it successfully.

Eg:

Execution of the program:
The program execution normally starts at the main function. After clearing the screen, the control of the program is taken to the hai( ) function. The executable statements in it i.e, the printf statement is executed. Now the control again is taken to the getch( ) function where it waits for a character to be given by the user.

Output:
WELCOME TO THE WORLD OF C LANGUAGE
Example program that shows the difference between calling and called functions.

OUTPUT: This function is called function which is called by main.
calling function is main.

Note: In the above program main () --------calling function and message () ----called function

3.9 Parameter passing: by value and by reference

Call by value and Call by reference in C

There are two methods to pass the data into the function in C language, i.e., call by value and call by reference.

Let's understand call by value and call by reference in c language one by one.

Call by value in C

• In call by value method, the value of the actual parameters is copied into the formal parameters. In other words, we can say that the value of the variable is used in the function call in the call by value method.
• In call by value method, we can not modify the value of the actual parameter by the formal parameter.
• In call by value, different memory is allocated for actual and formal parameters since the value of the actual parameter is copied into the formal parameter.
• The actual parameter is the argument which is used in the function call whereas formal parameter is the argument which is used in the function definition.

Let's try to understand the concept of call by value in c language by the example given below:

1. #include<stdio.h>  
2. Void change(int num) {    
3.    Printf("Before adding value inside function num=%d \n",num);    
4.    Num=num+100;    
5.    Printf("After adding value inside function num=%d \n", num);    
6. }    
7. Int main() {    
8.    Int x=100;    
9.    Printf("Before function call x=%d \n", x);    
10.    Change(x);//passing value in function    
11.    Printf("After function call x=%d \n", x);    
12. Return 0;  
13. }    

Output

Before function call x=100

Before adding value inside function num=100

After adding value inside function num=200

After function call x=100

Call by Value Example: Swapping the values of the two variables

1. #include <stdio.h>  
2. Void swap(int , int); //prototype of the function   
3. Int main()  
4. {  
5.    Int a = 10;  
6.    Int b = 20;   
7.    Printf("Before swapping the values in main a = %d, b = %d\n",a,b); // printing the value of a and b in main  
8.    Swap(a,b);  
9.    Printf("After swapping values in main a = %d, b = %d\n",a,b); // The value of actual parameters do not change by changing the formal parameters in call by value, a = 10, b = 20  
10. }  
11. Void swap (int a, int b)  
12. {  
13.    Int temp;   
14.    Temp = a;  
15.    a=b;  
16.    b=temp;  
17.    Printf("After swapping values in function a = %d, b = %d\n",a,b); // Formal parameters, a = 20, b = 10   
18. }  

Output

Before swapping the values in main a = 10, b = 20

After swapping values in function a = 20, b = 10

After swapping values in main a = 10, b = 20 

Call by reference in C

• In call by reference, the address of the variable is passed into the function call as the actual parameter.
• The value of the actual parameters can be modified by changing the formal parameters since the address of the actual parameters is passed.
• In call by reference, the memory allocation is similar for both formal parameters and actual parameters. All the operations in the function are performed on the value stored at the address of the actual parameters, and the modified value gets stored at the same address.

Consider the following example for the call by reference.

1. #include<stdio.h>  
2. Void change(int *num) {    
3.    Printf("Before adding value inside function num=%d \n",*num);    
4.    (*num) += 100;    
5.    Printf("After adding value inside function num=%d \n", *num);    
6. }      
7. Int main() {    
8.    Int x=100;    
9.    Printf("Before function call x=%d \n", x);    
10.    Change(&x);//passing reference in function    
11.    Printf("After function call x=%d \n", x);    
12. Return 0;  
13. }    

Output

Before function call x=100

Before adding value inside function num=100

After adding value inside function num=200

After function call x=200

Call by reference Example: Swapping the values of the two variables

1. #include <stdio.h>  
2. Void swap(int *, int *); //prototype of the function   
3. Int main()  
4. {  
5.    Int a = 10;  
6.    Int b = 20;   
7.    Printf("Before swapping the values in main a = %d, b = %d\n",a,b); // printing the value of a and b in main  
8.    Swap(&a,&b);  
9.    Printf("After swapping values in main a = %d, b = %d\n",a,b); // The values of actual parameters do change in call by reference, a = 10, b = 20  
10. }  
11. Void swap (int *a, int *b)  
12. {  
13.    Int temp;   
14.    Temp = *a;  
15.    *a=*b;  
16.    *b=temp;  
17.    Printf("After swapping values in function a = %d, b = %d\n",*a,*b); // Formal parameters, a = 20, b = 10   
18. }  

Output

Before swapping the values in main a = 10, b = 20

After swapping values in function a = 20, b = 10

After swapping values in main a = 20, b = 10 

Difference between call by value and call by reference in c

3.10 Recursive function

Recursion is the process which comes into existence when a function calls a copy of itself to work on a smaller problem. Any function which calls itself is called recursive function, and such function calls are called recursive calls. Recursion involves several numbers of recursive calls. However, it is important to impose a termination condition of recursion. Recursion code is shorter than iterative code however it is difficult to understand.

Recursion cannot be applied to all the problem, but it is more useful for the tasks that can be defined in terms of similar subtasks. For Example, recursion may be applied to sorting, searching, and traversal problems.

Generally, iterative solutions are more efficient than recursion since function call is always overhead. Any problem that can be solved recursively, can also be solved iteratively. However, some problems are best suited to be solved by the recursion, for example, tower of Hanoi, Fibonacci series, factorial finding, etc.

In the following example, recursion is used to calculate the factorial of a number.

1. #include <stdio.h>  
2. Int fact (int);  
3. Int main()  
4. {  
5.    Int n,f;  
6.    Printf("Enter the number whose factorial you want to calculate?");  
7.    Scanf("%d",&n);  
8.    f = fact(n);  
9.    Printf("factorial = %d",f);  
10. }  
11. Int fact(int n)  
12. {  
13.    If (n==0)  
14.    {  
15.        Return 0;  
16.    }  
17.    Else if ( n == 1)  
18.    {  
19.        Return 1;  
20.    }  
21.    Else   
22.    {  
23.        Return n*fact(n-1);  
24.    }  
25. }  

Output

Enter the number whose factorial you want to calculate?5

Factorial = 120

We can understand the above program of the recursive method call by the figure given below:

Recursive Function

A recursive function performs the tasks by dividing it into the subtasks. There is a termination condition defined in the function which is satisfied by some specific subtask. After this, the recursion stops and the final result is returned from the function.

The case at which the function doesn't recur is called the base case whereas the instances where the function keeps calling itself to perform a subtask, is called the recursive case. All the recursive functions can be written using this format.

Pseudocode for writing any recursive function is given below.

1. If (test_for_base)  
2. {  
3.    Return some_value;  
4. }  
5. Else if (test_for_another_base)  
6. {  
7.    Return some_another_value;  
8. }  
9. Else  
10. {  
11.    // Statements;  
12.    Recursive call;  
13. }  

Example of recursion in C

Let's see an example to find the nth term of the Fibonacci series.

1. #include<stdio.h>  
2. Int fibonacci(int);  
3. Void main ()  
4. {  
5.    Int n,f;  
6.    Printf("Enter the value of n?");  
7.    Scanf("%d",&n);  
8.    f = fibonacci(n);  
9.    Printf("%d",f);  
10. }  
11. Int fibonacci (int n)  
12. {  
13.    If (n==0)  
14.    {  
15.    Return 0;  
16.    }  
17.    Else if (n == 1)  
18.    {  
19.        Return 1;   
20.    }  
21.    Else  
22.    {  
23.        Return fibonacci(n-1)+fibonacci(n-2);  
24.    }  
25. }  

Output

Enter the value of n?12

144

Memory allocation of Recursive method

Each recursive call creates a new copy of that method in the memory. Once some data is returned by the method, the copy is removed from the memory. Since all the variables and other stuff declared inside function get stored in the stack, therefore a separate stack is maintained at each recursive call. Once the value is returned from the corresponding function, the stack gets destroyed. Recursion involves so much complexity in resolving and tracking the values at each recursive call. Therefore we need to maintain the stack and track the values of the variables defined in the stack.

Let us consider the following example to understand the memory allocation of the recursive functions.

1. Int display (int n)  
2. {  
3.    If(n == 0)  
4.        Return 0; // terminating condition  
5.    Else   
6.    {  
7.        Printf("%d",n);  
8.        Return display(n-1); // recursive call  
9.    }  
10. }  

Explanation

Let us examine this recursive function for n = 4. First, all the stacks are maintained which prints the corresponding value of n until n becomes 0, Once the termination condition is reached, the stacks get destroyed one by one by returning 0 to its calling stack. Consider the following image for more information regarding the stack trace for the recursive functions.

Text Books:

1. V. Rajaraman “Fundamentals of Computers” PHI publication, Fifth Edition.

2. E. Balaguruswamy,” Programming in C”, TMH Publication

3. Wei-Meng Lee” Android™ Application Development” Wiley Publication

Reference Books:

1. Pradeep K. Sinha, Priti Sinha, “Computer Fundamentals”, BPB Publication, Sixth Edition.

2. C.Xavier, Worldwide web Design with HTML, TMH Publication.

3. Yashwant Kanetkar,” Let us C”, Narosa Publication.

4. Kernighan Brian W. And Ritchie Dennis M, ‘The C Programming” Pearson Education.

5. Ed Burnette, “Hello, Android: Introducing Google's Mobile Development Platform”