Introduction
A one-dimensional array is a collection of elements of the same data type stored in consecutive memory locations. Arrays provide an efficient way to store and manage multiple values of the same type using a single variable name. Instead of declaring separate variables for each value, arrays allow you to group related data together and access individual elements using an index.
Arrays are fundamental data structures that form the foundation for more complex data structures. They are particularly useful for storing lists of data like student grades, temperature readings, or any collection of similar items that need to be processed together.
Key Concepts
Homogeneous Data: All elements in an array must be of the same data type.
Contiguous Memory: Array elements are stored in consecutive memory locations.
Index-Based Access: Elements are accessed using their position (index) in the array.
Zero-Based Indexing: In C, array indexing starts from 0, not 1.
Fixed Size: Once declared, the size of an array cannot be changed during program execution.
Array Declaration and Initialization
Declaration Syntax
data_type array_name[size];Examples of Declaration
int numbers[5]; // Array of 5 integers
float grades[10]; // Array of 10 floating-point numbers
char letters[26]; // Array of 26 charactersInitialization Methods
Method 1: Initialize During Declaration
int numbers[5] = {10, 20, 30, 40, 50};
float grades[4] = {85.5, 92.0, 78.3, 88.7};
char vowels[5] = {'a', 'e', 'i', 'o', 'u'};Method 2: Partial Initialization
int numbers[5] = {10, 20}; // First 2 elements initialized, rest are 0
// Equivalent to: {10, 20, 0, 0, 0}Method 3: Size Determined by Initialization
int numbers[] = {1, 2, 3, 4, 5}; // Size automatically becomes 5
char message[] = "Hello"; // Size becomes 6 (including '\0')Method 4: Initialize After Declaration
int numbers[5];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;Accessing Array Elements
Using Index Notation
#include <stdio.h>
int main() {
int numbers[5] = {10, 20, 30, 40, 50};
// Accessing elements
printf("First element: %d\n", numbers[0]); // Output: 10
printf("Third element: %d\n", numbers[2]); // Output: 30
printf("Last element: %d\n", numbers[4]); // Output: 50
// Modifying elements
numbers[1] = 25; // Change second element to 25
printf("Modified second element: %d\n", numbers[1]);
return 0;
}Reading Array Elements from User
#include <stdio.h>
int main() {
int size = 5;
int numbers[size];
printf("Enter %d numbers:\n", size);
for (int i = 0; i < size; i++) {
printf("Element %d: ", i + 1);
scanf("%d", &numbers[i]);
}
printf("You entered: ");
for (int i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}Common Array Operations
Finding Maximum and Minimum
#include <stdio.h>
int main() {
int numbers[] = {45, 23, 78, 12, 67, 34, 89};
int size = sizeof(numbers) / sizeof(numbers[0]);
int max = numbers[0], min = numbers[0];
for (int i = 1; i < size; i++) {
if (numbers[i] > max) {
max = numbers[i];
}
if (numbers[i] < min) {
min = numbers[i];
}
}
printf("Maximum: %d\n", max);
printf("Minimum: %d\n", min);
return 0;
}Calculating Sum and Average
#include <stdio.h>
int main() {
float grades[] = {85.5, 92.0, 78.3, 88.7, 95.2};
int size = sizeof(grades) / sizeof(grades[0]);
float sum = 0.0, average;
// Calculate sum
for (int i = 0; i < size; i++) {
sum += grades[i];
}
average = sum / size;
printf("Sum: %.2f\n", sum);
printf("Average: %.2f\n", average);
return 0;
}Searching in Array
#include <stdio.h>
int main() {
int numbers[] = {10, 25, 30, 45, 60};
int size = sizeof(numbers) / sizeof(numbers[0]);
int search_value = 30;
int found = 0;
for (int i = 0; i < size; i++) {
if (numbers[i] == search_value) {
printf("Value %d found at index %d\n", search_value, i);
found = 1;
break;
}
}
if (!found) {
printf("Value %d not found in the array\n", search_value);
}
return 0;
}Reversing an Array
#include <stdio.h>
int main() {
int numbers[] = {1, 2, 3, 4, 5};
int size = sizeof(numbers) / sizeof(numbers[0]);
printf("Original array: ");
for (int i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
// Reverse the array
for (int i = 0; i < size / 2; i++) {
int temp = numbers[i];
numbers[i] = numbers[size - 1 - i];
numbers[size - 1 - i] = temp;
}
printf("Reversed array: ");
for (int i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}Important Points
- Zero-Based Indexing: Remember that array indices start from 0, not 1
- Bounds Checking: C doesn’t check array bounds automatically - accessing out-of-bounds elements causes undefined behavior
- Size Calculation: Use
sizeof(array) / sizeof(array[0])to get array size - Memory Efficiency: Arrays store elements in contiguous memory, making access efficient
- Pass by Reference: When passed to functions, arrays are passed by reference (address)
Common Mistakes and Solutions
Mistake 1: Array Index Out of Bounds
// Wrong - accessing beyond array size
int arr[5] = {1, 2, 3, 4, 5};
printf("%d", arr[5]); // Undefined behavior! Valid indices: 0-4
// Correct - stay within bounds
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}Mistake 2: Using = for Array Assignment
// Wrong - cannot assign arrays directly
int arr1[5] = {1, 2, 3, 4, 5};
int arr2[5];
arr2 = arr1; // Error!
// Correct - copy element by element
for (int i = 0; i < 5; i++) {
arr2[i] = arr1[i];
}Mistake 3: Confusing Array Size
// Be careful with array size
int arr[10];
int size = sizeof(arr) / sizeof(int); // Correct: gives 10
// Don't confuse with number of initialized elementsPractical Examples
Grade Management System
#include <stdio.h>
int main() {
float grades[5];
int num_students = 5;
float sum = 0, average;
int above_average = 0, below_average = 0;
// Input grades
printf("Enter grades for %d students:\n", num_students);
for (int i = 0; i < num_students; i++) {
printf("Student %d: ", i + 1);
scanf("%f", &grades[i]);
sum += grades[i];
}
average = sum / num_students;
// Count students above and below average
for (int i = 0; i < num_students; i++) {
if (grades[i] > average) {
above_average++;
} else if (grades[i] < average) {
below_average++;
}
}
printf("\n=== GRADE REPORT ===\n");
printf("Average grade: %.2f\n", average);
printf("Students above average: %d\n", above_average);
printf("Students below average: %d\n", below_average);
return 0;
}Simple Frequency Counter
#include <stdio.h>
int main() {
int numbers[] = {1, 2, 3, 2, 1, 3, 2, 4, 1};
int size = sizeof(numbers) / sizeof(numbers[0]);
int frequency[10] = {0}; // Assuming numbers are 0-9
// Count frequencies
for (int i = 0; i < size; i++) {
if (numbers[i] >= 0 && numbers[i] < 10) {
frequency[numbers[i]]++;
}
}
printf("Number frequencies:\n");
for (int i = 0; i < 10; i++) {
if (frequency[i] > 0) {
printf("Number %d appears %d times\n", i, frequency[i]);
}
}
return 0;
}Array Sorting (Simple Bubble Sort)
#include <stdio.h>
int main() {
int numbers[] = {64, 34, 25, 12, 22, 11, 90};
int size = sizeof(numbers) / sizeof(numbers[0]);
printf("Original array: ");
for (int i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
// Bubble sort
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - i - 1; j++) {
if (numbers[j] > numbers[j + 1]) {
// Swap elements
int temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
}
}
}
printf("Sorted array: ");
for (int i = 0; i < size; i++) {
printf("%d ", numbers[i]);
}
printf("\n");
return 0;
}Summary
One-dimensional arrays are fundamental data structures that allow efficient storage and manipulation of collections of homogeneous data. They provide indexed access to elements, enabling systematic processing of related data items. Key concepts include zero-based indexing, contiguous memory allocation, and fixed-size limitations. Arrays are essential for implementing algorithms, managing collections of data, and building more complex data structures. Understanding array operations like searching, sorting, and statistical calculations forms the foundation for more advanced programming concepts. Proper handling of array bounds and understanding memory layout are crucial for writing reliable and efficient C programs. Arrays serve as building blocks for numerous applications including data processing, mathematical computations, and algorithm implementation.
Part of BCA Programming with C Course (UGCOA22J201)