Unit 3

3.1 Introduction to Array & Its Types-

Array is a 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, 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[X] 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, 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 arr[ ] of type int, use this statement −
int arr[10];
Here arr is a variable array which is sufficient to hold up to 10 integer numbers.

Initializing Arrays
You can initialize an array in C either one by one or using a single statement as follows
−
int arr[5] = {100, 20, 34, 70, 500};

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 −
int arr[5] = {100, 20, 34, 70, 500};
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 −
arr[4] = 500;
The above statement assigns the 5th element in the array with a value of 500. 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 –

arr

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 −
int salary = arr[4];
The above statement will take the 4th 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 –

Example Program
3.2 Declaration, initialization of array, accessing elements of an array

#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;
}

3.2 adding deleting sorting & searching in an array

1) Adding elements in array
#include<stdio.h>

int main()
{
int arr[5], i;

for(i = 0; i < 5; i++)

{
printf("Enter a[%d]: ", i);
scanf("%d", &arr[i]);
}

printf("\nPrinting elements of the array: \n\n");

for(i = 0; i < 5; i++)

{
printf("%d ", arr[i]);
}

// signal to operating system program ran fine

return 0;
}

2) Deleting elements in array

#include <stdio.h>
int main()
{
int array[100], position, c, n;

printf("Enter number of elements in array\n");

scanf("%d", &n);

printf("Enter %d elements\n", n);

for (c = 0; c < n; c++)

scanf("%d", &array[c]);

printf("Enter the location where you wish to delete element\n");

scanf("%d", &position);

if (position >= n+1)

printf("Deletion not possible.\n");
 else
{
for (c = position - 1; c < n - 1; c++)
array[c] = array[c+1];

printf("Resultant array:\n");

for (c = 0; c < n - 1; c++)

printf("%d\n", array[c]);
}

return 0;
}

3) Sorting elements in array

/*C program to sort an one dimensional array in ascending order.*/
#include <stdio.h>
#define MAX 100
int main()
{
int arr[MAX],n,i,j;
int temp;

printf("Enter total number of elements: ");

scanf("%d",&n);

//read array elements

printf("Enter array elements:\n");
for(i=0;i< n;i++)
{
printf("Enter element %d: ",i+1);
scanf("%d",&arr[i]);
}

//sort array
for(i=0;i< n;i++)
{
for(j=i+1;j< n;j++)
{
if(arr[i]>arr[j])
{
temp =arr[i];
arr[i] =arr[j];
arr[j] =temp;
}
}
}
 printf("\nArray elements after sorting:\n");
for(i=0;i< n;i++)
{
printf("%d\n",arr[i]);
}
return 0;
}

4) Searching elements in array

#include<stdio.h>

int main() {
int a[30], ele, num, i;

printf("\nEnter no of elements :");

scanf("%d", &num);

printf("\nEnter the values :");

for (i = 0; i < num; i++) {
scanf("%d", &a[i]);
}

//Read the element to be searched

printf("\nEnter the elements to be searched :");
scanf("%d", &ele);

//Search starts from the zeroth location

i = 0;
while (i < num && ele != a[i]) {
i++;
}

//If i < num then Match found

if (i < num) {
printf("Number found at the location = %d", i + 1);
} else {
printf("Number not found");
}

return (0);
}

Multi Dimensional Arrays

C programming language allows multidimensional arrays. Here is the general form of a

multidimensional array declaration −
type name[size1][size2]...[sizeN];
For example, the following declaration creates a three dimensional integer array −
int threedim[5][10][4];

Two-dimensional Arrays
The simplest form of multidimensional array is the two-dimensional array. A two-
dimensional array is, in essence, a list of one-dimensional arrays. To declare a two-
dimensional integer array of size [x][y], you would write something as follows −
type arrayName [ x ][ y ];
Where type can be any valid C data type and arrayName will be a valid C identifier. A
two-dimensional array can be considered as a table which will have x number of rows
and y number of columns. A two-dimensional array a, which contains three rows and
four columns can be shown as follows −

Thus, every element in the array a is identified by an element name of the form a[ i ][ j
], where 'a' is the name of the array, and 'i' and 'j' are the subscripts that uniquely identify
each element in 'a'.

Initializing Two-Dimensional Arrays

Multidimensional arrays may be initialized by specifying bracketed values for each row.
Following is an array with 3 rows and each row has 4 columns.
int a[3][4] = {
{0, 1, 2, 3} , /* initializers for row indexed by 0 */
{4, 5, 6, 7} , /* initializers for row indexed by 1 */
{8, 9, 10, 11} /* initializers for row indexed by 2 */
};

The nested braces, which indicate the intended row, are optional. The following
initialization is equivalent to the previous example −
int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

Accessing Two-Dimensional Array Elements

An element in a two-dimensional array is accessed by using the subscripts, i.e., row
index and column index of the array. For example −
int val = a[2][3];
The above statement will take the 4th element from the 3rd row of the array. You can
verify it in the above figure. Let us check the following program where we have used a
nested loop to handle a two-dimensional array −

Live Demo
#include <stdio.h>

int main () {

/* an array with 5 rows and 2 columns*/

int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
int i, j;

/* output each array element's value */

for ( i = 0; i < 5; i++ ) {

for ( j = 0; j < 2; j++ ) {

printf("a[%d][%d] = %d\n", i,j, a[i][j] );
}
}

return 0;
}
3.3 Introduction to String, Initializing, Declaring and Display of string
Strings are actually one-dimensional array of characters terminated by a null character
'\0'. Thus a null-terminated string contains the characters that comprise the string
followed by a null.
The following declaration and initialization create a string consisting of the word "Hello".
To hold the null character at the end of the array, the size of the character array
containing the string is one more than the number of characters in the word "Hello."
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
If you follow the rule of array initialization then you can write the above statement as
follows −
char greeting[] = "Hello";
Following is the memory presentation of the above defined string in C/C++ −

Actually, you do not place the null character at the end of a string constant. The C
compiler automatically places the '\0' at the end of the string when it initializes the array.
Let us try to print the above mentioned string −

Live Demo
#include <stdio.h>

int main () {

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

printf("Greeting message: %s\n", greeting );
return 0;
}

3.3 String handling functions

Sr.No. Function & Purpose

 1 strcpy(s1, s2);
Copies string s2 into string s1.

2 strcat(s1, s2);
Concatenates string s2 onto the end of string s1.

3 strlen(s1);
Returns the length of string s1.

4
strcmp(s1, s2);
Returns 0 if s1 and s2 are the same; less than 0 if s1<s2; greater than 0
if s1>s2.

5 strchr(s1, ch);
Returns a pointer to the first occurrence of character ch in string s1.

6 strstr(s1, s2);
Returns a pointer to the first occurrence of string s2 in string s1.

7 strupr() - The strupr( ) function is used to converts a given string to uppercase.

8 strlwr() - The strlwr( ) function is used to converts a given string to lowercase.

#include <stdio.h>
#include <string.h>

int main () {

char str1[12] = "Hello";

char str2[12] = "World";
char str3[12];
int len ;

/* copy str1 into str3 */

strcpy(str3, str1);
printf("strcpy( str3, str1) : %s\n", str3 );

/* concatenates str1 and str2 */

strcat( str1, str2);
 printf("strcat( str1, str2): %s\n", str1 );

/* total lenghth of str1 after concatenation */

len = strlen(str1);
printf("strlen(str1) : %d\n", len );

/* Covert Str1 to Uppercase */

printf("strupr(str1) : %s\n", str1 );

/* Covert Str1 to Uppercase */

printf("strlwr(str2) : %s\n", str2 );

return 0;
}

strcpy()
#include <stdio.h>

#include <string.h>

int main () {
char str1[15];
char str2[15];
int ret;

strcpy(str1, "abcdef");
strcpy(str2, "ABCDEF");

ret = strcmp(str1, str2);

if(ret < 0) {
printf("str1 is less than str2");
} else if(ret > 0) {
printf("str2 is less than str1");
} else {
printf("str1 is equal to str2");
}

return(0);
}