Definition: An array is a collection of variables of the same data type that are referenced by a common name. The specific element in an array is accessed by an index.

1. Declaration Syntax:
To declare an array, you specify the type of the elements, the name of the array, and the number of elements (size).

2. Initialization:
Arrays can be initialized at the time of declaration.

• Complete Initialization:
  int numbers[5] = {10, 20, 30, 40, 50};
• Partial Initialization:
  int numbers[5] = {10, 20}; (Remaining elements become 0).
• Initialization without Size:
  int numbers[] = {1, 2, 3}; (Compiler determines size as 3).

Memory Storage:
Elements of a 1D array are stored in contiguous memory locations. The index starts from 0.

Address Calculation Formula:
The address of the element is calculated as:

Calculation:

• Base Address () = 1000
• Size of integer () = 2 bytes
• Index () = 5

Therefore, the element is stored at address 1010.

Here is the C program to find the sum and average:

c

include <stdio.h>

int main() {
int n, i;
float sum = 0, average;
int arr[100];

printf("Enter the number of elements: ");
scanf("%d", &n);

// Input array elements
for(i = 0; i < n; ++i) {
    printf("Enter number %d: ", i + 1);
    scanf("%d", &arr[i]);
    sum += arr[i]; // Add to sum
}

average = sum / n;

printf("Sum = %.2f

", sum);
printf("Average = %.2f
", average);

return 0;

}

Logic:

1. Read the number of elements .
2. Use a loop to accept input and simultaneously add the value to the sum variable.
3. Divide sum by n to get the average.

Differences:

2D Array Syntax:

Example: int matrix[3][3]; declares a matrix with 3 rows and 3 columns.

1. Row-Major Order:
In this method, elements are stored row by row. The entire first row is stored, followed by the second row, and so on. C uses Row-Major ordering.

2. Column-Major Order:
Elements are stored column by column. The entire first column is stored, followed by the second column, etc.

Address Calculation (Row-Major):
Given an array (where is rows, is columns), Base Address , and element size .
To find the address of element at row and column ():

We must skip full rows to reach the starting of the row. Each row has elements.
Total elements skipped = .

Formula:

c

include <stdio.h>

int main() {
int a[3][3], b[3][3], sum[3][3];
int i, j;

// Input Matrix A
printf("Enter elements of 1st matrix:

");
for (i = 0; i < 3; ++i)
for (j = 0; j < 3; ++j)
scanf("%d", &a[i][j]);

// Input Matrix B
printf("Enter elements of 2nd matrix:

");
for (i = 0; i < 3; ++i)
for (j = 0; j < 3; ++j)
scanf("%d", &b[i][j]);

// Adding Matrices
for (i = 0; i < 3; ++i)
    for (j = 0; j < 3; ++j)
        sum[i][j] = a[i][j] + b[i][j];

// Displaying Result
printf("Sum of two matrices: 

");
for (i = 0; i < 3; ++i) {
for (j = 0; j < 3; ++j) {
printf("%d ", sum[i][j]);
}
printf("
");
}
return 0;
}

Passing Mechanism:
When an array is passed to a function, the base address (address of the first element) of the array is passed, not a copy of the entire array. This is effectively Call by Reference.

Syntax:

• Function Prototype: void myFunction(int arr[], int size);
• Function Call: myFunction(myArray, 5); (Note: brackets [] are not used in the call).

Difference from Single Variable:

1. Single Variable: Usually passed by value (a copy is created). Changes inside the function do not affect the original variable.
2. Array: Passed by address. Any modification made to the array elements inside the function will modify the original array in the calling function.

Logic: Two matrices and can be multiplied only if . The resulting matrix will be .

c

include <stdio.h>

int main() {
int a[10][10], b[10][10], mul[10][10];
int m, n, p, q, i, j, k;

printf("Enter rows and columns for first matrix: ");
scanf("%d %d", &m, &n);
printf("Enter rows and columns for second matrix: ");
scanf("%d %d", &p, &q);

if (n != p) {
    printf("Error! Matrices cannot be multiplied.");
} else {
    // Input A
    printf("Enter elements of matrix A:

");
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
scanf("%d", &a[i][j]);

    // Input B
    printf("Enter elements of matrix B:

");
for (i = 0; i < p; i++)
for (j = 0; j < q; j++)
scanf("%d", &b[i][j]);

    // Initialization of result matrix
    for (i = 0; i < m; i++)
        for (j = 0; j < q; j++)
            mul[i][j] = 0;

    // Multiplication Logic
    for (i = 0; i < m; i++) {
        for (j = 0; j < q; j++) {
            for (k = 0; k < n; k++) {
                mul[i][j] += a[i][k] * b[k][j];
            }
        }
    }

    // Output
    printf("Resultant Matrix:

");
for (i = 0; i < m; i++) {
for (j = 0; j < q; j++)
printf("%d\t", mul[i][j]);
printf("
");
}
}
return 0;
}

Algorithm for Insertion:
Assuming an array arr with n elements and capacity to hold more.

1. Input: Read the element to be inserted (key) and the position (pos) where it needs to be inserted.
2. Validation: Check if the array is full. If yes, print "Overflow".
3. Shift Elements:
   • Start a loop from the last index (n-1) down to the target index (pos-1).
   • Move the element at current index i to i+1.
4. Insert: Place the key at the specified position.
5. Update Size: Increment the number of elements by 1.

c
void deleteElement(int arr[], int n, int pos) {
// pos is the user-friendly position (1-based)
// n is the pointer to the current size of array

if (pos < 1 || pos > *n) {
    printf("Invalid position!

");
return;
}

// Shifting elements to the left to overwrite the deleted element
// Loop starts from index pos-1 (the element to delete)
for (int i = pos - 1; i < *n - 1; i++) {
    arr[i] = arr[i + 1];
}

// Decrement the size of the array
(*n)--;
printf("Element deleted successfully.

");
}

Explanation:

1. The function takes the array, a pointer to the size (so the change persists), and the position.
2. It shifts all elements from pos to the end one step to the left ().
3. Finally, it reduces the count of elements.

Definition:
Linear Search (or Sequential Search) is the simplest searching algorithm. It traverses the array sequentially from the first element to the last element, checking if the current element matches the search key.

C Program:
c

include <stdio.h>

int main() {
int array[100], search, c, n;

printf("Enter number of elements in array

");
scanf("%d", &n);

printf("Enter %d integer(s)

", n);
for (c = 0; c < n; c++)
scanf("%d", &array[c]);

printf("Enter a number to search

");
scanf("%d", &search);

for (c = 0; c < n; c++) {
    if (array[c] == search) {
        printf("%d is present at location %d.

", search, c+1);
break;
}
}

if (c == n)
    printf("%d isn't present in the array.

", search);

return 0;

}

Logic:
Binary Search is a divide-and-conquer algorithm.

1. Compare the search key with the middle element of the array.
2. If the key matches the middle element, the search is successful.
3. If the key is smaller than the middle element, repeat the search in the left half.
4. If the key is larger, repeat the search in the right half.
5. Repeat until the key is found or the interval is empty.

Prerequisite:
The array must be sorted (in ascending or descending order).

Time Complexity:
In every step, the search space is divided by 2.

• Best Case: (Element found at middle).
• Worst Case: .

Iterative Binary Search Implementation:
c

include <stdio.h>

int binarySearch(int arr[], int l, int r, int x) {
while (l <= r) {
int m = l + (r - l) / 2;

    // Check if x is present at mid
    if (arr[m] == x)
        return m;

    // If x greater, ignore left half
    if (arr[m] < x)
        l = m + 1;

    // If x is smaller, ignore right half
    else
        r = m - 1;
}
return -1; // Not found

}

int main() {
int arr[] = {2, 3, 4, 10, 40};
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
int result = binarySearch(arr, 0, n - 1, x);

if(result == -1)
    printf("Element not found");
else
    printf("Element found at index %d", result);
return 0;

}

Definition:
Bubble Sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.

Working Principle:

1. Compare and . If , swap them.
2. Compare and . Swap if necessary.
3. Continue this until the end of the array. After the first pass, the largest element "bubbles up" to the last position.
4. Repeat the process for the remaining elements (, , etc.).

Example Pass (Array: 5, 1, 4, 2, 8):

• ( 5 1 4 2 8 ) ( 1 5 4 2 8 ) // Swap 5, 1
• ( 1 5 4 2 8 ) ( 1 4 5 2 8 ) // Swap 5, 4
• ( 1 4 5 2 8 ) ( 1 4 2 5 8 ) // Swap 5, 2
• ( 1 4 2 5 8 ) ( 1 4 2 5 8 ) // No Swap
• Largest element 8 is now at the end.

c

include <stdio.h>

int main() {
int array[100], n, c, d, swap;

printf("Enter number of elements

");
scanf("%d", &n);

printf("Enter %d integers

", n);
for (c = 0; c < n; c++)
scanf("%d", &array[c]);

// Bubble Sort Logic
for (c = 0; c < n - 1; c++) {
    for (d = 0; d < n - c - 1; d++) {
        if (array[d] > array[d+1]) { /* For descending order use < */
            swap = array[d];
            array[d] = array[d+1];
            array[d+1] = swap;
        }
    }
}

printf("Sorted list in ascending order:

");
for (c = 0; c < n; c++)
printf("%d
", array[c]);

return 0;

}

Input: {64, 34, 25, 12, 22}

Pass 1:

• Compare 64, 34 -> Swap -> {34, 64, 25, 12, 22}
• Compare 64, 25 -> Swap -> {34, 25, 64, 12, 22}
• Compare 64, 12 -> Swap -> {34, 25, 12, 64, 22}
• Compare 64, 22 -> Swap -> {34, 25, 12, 22, 64}
• Result: 64 is sorted at the end.

Pass 2:

• Compare 34, 25 -> Swap -> {25, 34, 12, 22, 64}
• Compare 34, 12 -> Swap -> {25, 12, 34, 22, 64}
• Compare 34, 22 -> Swap -> {25, 12, 22, 34, 64}
• Result: 34 is sorted.

Pass 3:

• Compare 25, 12 -> Swap -> {12, 25, 22, 34, 64}
• Compare 25, 22 -> Swap -> {12, 22, 25, 34, 64}
• Result: 25 is sorted.

Pass 4:

• Compare 12, 22 -> No Swap -> {12, 22, 25, 34, 64}
• Result: Array is fully sorted.

The transpose of a matrix is obtained by swapping rows with columns. Element at [i][j] moves to [j][i].

c

include <stdio.h>

int main() {
int a[10][10], transpose[10][10], r, c, i, j;
printf("Enter rows and columns: ");
scanf("%d %d", &r, &c);

printf("Enter matrix elements:

");
for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j)
scanf("%d", &a[i][j]);

// Computing transpose
for (i = 0; i < r; ++i)
    for (j = 0; j < c; ++j) {
        transpose[j][i] = a[i][j];
    }

printf("Transpose of the matrix:

");
for (i = 0; i < c; ++i) { // Note: Loop runs c times then r times
for (j = 0; j < r; ++j) {
printf("%d ", transpose[i][j]);
}
printf("
");
}
return 0;
}

Advantages:

1. Random Access: Any element can be accessed instantly using the index ( complexity).
2. Code Optimization: Less code required to store multiple variables of the same type.
3. Traversal: Easy to traverse using loops.
4. Sorting/Searching: Algorithms like Binary search work efficiently on arrays.

Limitations:

1. Fixed Size: The size of the array must be known at compile time (static arrays). It cannot be resized dynamically at runtime.
2. Contiguous Memory: Requires a single block of contiguous memory, which might cause allocation failures if memory is fragmented.
3. Insertion/Deletion: Expensive operations because they require shifting existing elements to maintain order.

c

include <stdio.h>

int main() {
int arr[50], n, i, max, min, maxPos, minPos;

printf("Enter number of elements: ");
scanf("%d", &n);

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

// Initialize with first element
max = arr[0]; min = arr[0];
maxPos = 0; minPos = 0;

for (i = 1; i < n; i++) {
    if (arr[i] > max) {
        max = arr[i];
        maxPos = i;
    }
    if (arr[i] < min) {
        min = arr[i];
        minPos = i;
    }
}

printf("Largest element is %d at index %d

", max, maxPos);
printf("Smallest element is %d at index %d
", min, minPos);

return 0;

}