Notes on Array

Definition:In C, an array is a data structure that stores a fixed-size

sequential collection of elements of the same data type. Arrays are used
to store multiple values in a single variable, instead of declaring separate
variables for each value.

Syntax of Array Declaration: data_type array_name[array_size]

Example: int numbers[5]; // Declares an array of 5

integers

Here:
 int = data type
 numbers = name of the array
 5 = number of elements it can store (index from 0 to 4)

Initialize an array at the time of declaration: Values to an array can

be assigned during its declaration. This process is known as initialization
at the time of declaration. Syntax for this is:

data_type array_name[size] = {value1, value2, ..., valueN};

Example: int numbers[5] = {10, 20, 30, 40, 50};

Here, the array numbers is created with a size of 5. Each value is

assigned in order to each index viz. numbers[0] = 10, numbers[1] = 20,
…, numbers[4] = 50

Size determined by the compiler: If the size is omitted while

initializing an array, the compiler will automatically calculate the size
based on the number of values provided.

Example: int numbers[] = {10, 20, 30, 40, 50}; //

Automatically size = 5

Since there are 5 values in the initializer list, the compiler sets the size of
numbers to 5. This saves manual effort and avoids mismatch between
declared size and number of initial values.

Types of Arrays: On the basis of dimensions, there are 3 type of array in

C:-

1. One-Dimensional Array (1D):

 It is a linear list of elements.
 Its syntax for declaration is : int arr[10];
 It is used for simple lists, like marks, prices, etc.

2. Two-Dimensional Array (2D):

 A table of rows and columns.
 Syntax: int matrix[3][4];
 Used for matrices, tables, grids.

3. Multi-Dimensional Array:
 Arrays with more than two dimensions.
 Syntax: int arr[3][4][2];
 Used in advanced applications like 3D graphics or tensor
computations.

Memory Representation of Arrays

 Computers store arrays in linear memory (one-dimensional).

For 1D array suppose A be a 1D array of size N. Each
element takes size bytes. Base is the base address. You want
to access A[i]
Address(A[i]) = Base + (i × size)
Ex.:- If Base = 1000, size = 4, and i = 3, then:
Address(A[3]) = 1000 + (3 × 4) = 1012

For multi-dimensional arrays (e.g., 2D arrays), we use

mapping techniques to store them in linear memory.
 Two standard ways to represent 2D arrays in memory:
 - Row-Major Order
- Column-Major Order

Row-Major Order

 Definition: In Row-Major Order, the rows of the array are

stored one after the other in memory.
 Example:
A[3][4] =
[ [1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12] ]
 Memory Layout:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
 Address Calculation (Row-Major):
Address(A[i][j]) = Base + ((i * N) + j) * size
Where:
Base = Base address of the array
i = Row index
j = Column index
N = Total number of columns
size = Size of each element in bytes
Column-Major Order

 Definition: In Column-Major Order, the columns of the array

are stored one after the other in memory.
 Example:
A[3][4] =
[ [1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12] ]
 Memory Layout:
[1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12]
 Address Calculation (Column-Major):
Address(A[i][j]) = Base + ((j * M) + i) * size
Where:
Base = Base address of the array
i = Row index
j = Column index
M = Total number of rows
size = Size of each element in bytes

Comparison Table

Feature Row-Major Column-Major

Order Order

Storage Style Rows stored Columns stored

sequentially sequentially

Formula Base + ((i × N) Base + ((j × M)

+ j) × size + i) × size

Efficient Row-wise Column-wise

Traversal

Used In C, C++, Java Fortran,

MATLAB

Real-Time Code Example

#include <stdio.h>
int main() {
int A[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9,10,11,12}
};
printf("Row-Major Order Traversal:\n");
for(int i = 0; i < 3; i++) {
for(int j = 0; j < 4; j++) {
printf("%d ", A[i][j]);
}
}

Sparse Matrices and Their

Representation
Definition:

A sparse matrix is a matrix in which most of the elements are zero.

Characteristics:
- Contains few non-zero elements.
- Saves memory and improves computation time.

- Opposite to sparse, a matrix where most elements are non-zero is called

Dense Matrix.

Why Use Sparse Matrix Representation?

- To avoide wastes memory storing zeroes.

- Improves efficiency.
- Easier mathematical operations on large matrices.

Types of Sparse Matrix Representations

Triplet (Coordinate List) Representation

Stores only non-zero elements with row and column indices.

Structure:
[Row, Column, Value]

Example:
Matrix (4x5): Triplet Representation:
0 0 0 5 0 Row Col Value
0 0 8 0 0 0 3 5
0 0 0 0 0 1 2 8
0 6 0 0 9 3 1 6
3 4 9

Compressed Sparse Row (CSR) Format

Efficient for row-wise operations.

Components:
- Values: All non-zero elements
- Column Indices: Corresponding column of each non-zero value
- Row Pointers: Index in Values[] where each row starts
Example:
Values: [5, 8, 6, 9]
Column Indices: [3, 2, 1, 4]
Row Pointers: [0, 1, 3,3]

Compressed Sparse Column (CSC) Format

Efficient for column-wise operations.

Similar to CSR, but compresses columns instead of rows.

Real-Time Applications of Sparse Matrices

- Machine Learning: Feature vectors in NLP, image recognition

- Graph Algorithms: Sparse adjacency matrices
- Scientific Computing: Finite element methods
- Databases and Search Engines: Document-term matrices

C Code Example for Triplet Representation

#include <stdio.h>
int main() {
int rows = 4, cols = 5;
int matrix[4][5] = {
{0, 0, 0, 5, 0},
{0, 0, 8, 0, 0},
{0, 0, 0, 0, 0},
{0, 6, 0, 0, 9}
};
printf("Triplet Representation:\n");
printf("Row Col Value\n");

for (int i = 0; i < rows; i++) {

for (int j = 0; j < cols; j++) {
if (matrix[i][j] != 0) {
printf("%3d %3d %5d\n", i, j, matrix[i][j]);
}
}
}

return 0;
}

C program that demonstrates various operations on a 1D array

#include <stdio.h>

#define SIZE 100

// Function to traverse and display the array

void traverse(int arr[], int n) {

printf("Array elements: ");

for (int i = 0; i < n; i++)

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

printf("\n");

// Function to reverse the array

void reverse(int arr[], int n) {

printf("Reversed array: ");

for (int i = n - 1; i >= 0; i--)

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

printf("\n");

// Function to insert an element at a given position

int insert(int arr[], int n, int pos, int value) {

if (n >= SIZE) {

printf("Insertion failed: Array is full.\n");

return n;

if (pos < 0 || pos > n) {

printf("Insertion failed: Invalid position.\n");

return n;
}

for (int i = n; i > pos; i--)

arr[i] = arr[i - 1];

arr[pos] = value;

return n + 1;

// Function to delete an element from a given position

int delete(int arr[], int n, int pos) {

if (pos < 0 || pos >= n) {

printf("Deletion failed: Invalid position.\n");

return n;

for (int i = pos; i < n - 1; i++)

arr[i] = arr[i + 1];

return n - 1;

// Function to search for an element

void search(int arr[], int n, int value) {

for (int i = 0; i < n; i++) {

if (arr[i] == value) {

printf("Element %d found at position %d\n",

value, i);

return;

printf("Element %d not found in array\n", value);

}
// Function to sort the array using bubble sort

void sort(int arr[], int n) {

for (int i = 0; i < n - 1; i++)

for (int j = 0; j < n - i - 1; j++)

if (arr[j] > arr[j + 1]) {

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

printf("Sorted array: ");

traverse(arr, n);

int main() {

int arr[SIZE], n = 0, choice, value, pos;

printf("Enter initial number of elements (max %d): ",

SIZE);

scanf("%d", &n);

printf("Enter elements:\n");

for (int i = 0; i < n; i++)

scanf("%d", &arr[i]);

while (1) {

printf("\nMenu:\n");

printf("1. Traverse\n2. Reverse\n3. Insert\n4.

Delete\n5. Search\n6. Sort\n7. Exit\n");

printf("Enter your choice: ");

scanf("%d", &choice);
switch (choice) {

case 1:

traverse(arr, n);

break;

case 2:

reverse(arr, n);

break;

case 3:

printf("Enter position and value to insert: ");

scanf("%d %d", &pos, &value);

n = insert(arr, n, pos, value);

break;

case 4:

printf("Enter position to delete: ");

scanf("%d", &pos);

n = delete(arr, n, pos);

break;

case 5:

printf("Enter value to search: ");

scanf("%d", &value);

search(arr, n, value);

break;

case 6:

sort(arr, n);

break;

case 7:

return 0;

default:

printf("Invalid choice!\n");
}

Selection Sort :

#include <stdio.h>

// Selection sort implementation

void selectionSort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {

int min = i;

for (int j = i + 1; j < n; j++) {

if (arr[j] < arr[min])

min = j;

if (min != i) {

int temp = arr[min];

arr[min] = arr[i];

arr[i] = temp;

int main() {

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

int n = sizeof(arr) / sizeof(arr[0]);

// Perform Selection Sort

selectionSort(arr,n);
for (int i = 0; i < n; i++)

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

return 0;