There is only one subscript in a one-dimensional array in programming. A one-dimensional array is like a list with each element accessible by an index. The subscripts start at 0 and go up to n-1, where n is the number of elements in the array.
So for example, if you have an array with 5 elements, the subscripts would be 0, 1, 2, 3, and 4. There is only one subscript since it is a one-dimensional array. With multi-dimensional arrays, you would have subscripts for each dimension.
What is an Array?
An array is a data structure that stores a collection of elements of the same data type. For example, an array can store a list of integers, a list of characters, etc.
The main features of an array are:
– It contains elements of the same data type like integers, characters, etc.
– The elements are stored in a contiguous block of memory.
– Each element can be accessed directly using an index.
Some key advantages of using arrays are:
– Fast access to elements using index. Access time is constant as it takes the same time to access any element.
– Arrays allow sequential access to elements. You can traverse the array element by element easily.
– Arrays allow random access to elements using index. You can get any element instantly using its index.
– Arrays provide ease of initialization with the same value.
– Arrays allow operations like search, insertion, deletion, sorting etc.
Arrays form an essential part of many programming algorithms and data structures. Almost all programs use arrays or data structures built on top of arrays like array lists, vectors, matrices, etc.
Declaring Arrays
To use an array in a program, you first need to declare a variable of array type. The syntax varies based on the programming language but usually involves:
– Data type of elements
– Name of the array variable
– Size or length of the array
For example, to declare an array of 5 integers in C++ you would write:
“`cpp
int arr[5];
“`
This allocates space for an array of 5 integers and names the array variable as arr.
Similarly, in Java you would write:
“`java
int[] arr = new int[5];
“`
This both declares and allocates memory for an array of 5 integers referenced by arr.
The size or length of an array is fixed once declared in most languages like C, C++, Java. Dynamic sized arrays like ArrayList in Java can change in size.
Accessing Array Elements
The array elements are accessed using an index or subscript. Indexes start at 0 for the first element and go up to array size – 1 for the last element.
For example, for an array of 5 elements, the indexes would be 0, 1, 2, 3, 4.
To access an element, specify the array name and index in square brackets. For example:
“`
arr[0]
arr[1]
arr[2]
“`
This accesses the 1st, 2nd and 3rd element of the array arr respectively.
Trying to access an element using a subscript outside the array bounds leads to errors. Array indexes must be within 0 to array size – 1.
One Dimensional Arrays
A one dimensional array contains elements accessed using a single subscript or index. It can be visualized as a row of elements.
For example, an array storing 10 numbers can be depicted as:
“`
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
“`
The numbers in square brackets denote the index for each element. Some key points:
– Only one index is needed to access each element
– Indexes start at 0 and go up to n-1 where n is array size
– Elements are stored in contiguous memory
One dimensional arrays are useful for storing and accessing sequential data, like:
– List of numbers
– Characters in a string
– Values to plot on a graph
– Pixel values in an image row
Operations like search, sorting, insertion, deletion are easy to implement on one-D arrays.
Examples
Here is some sample code to declare and initialize a one-D array:
“`cpp
// C++
#include
using namespace std;
int main() {
int arr[5] = {1, 2, 3, 4, 5};
cout << "Element at index 3: " << arr[3]; return 0; } ``` This creates an integer array arr of size 5 and initializes elements using list initialization. Element arr[3], that is 4, is printed. Similarly in Java: ```java // Java class Main { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; System.out.println("Element at index 3: " + arr[3]); } } ``` The array can also be declared and then elements assigned like: ```cpp double arr[5]; // Declare arr[0] = 1.2; arr[1] = 2.3; arr[2] = 3.4; ``` This first declares a double array of size 5, then assigns values to first three elements.
Multidimensional Arrays
A multidimensional array contains elements accessed using two or more subscripts or indexes.
Some common types are:
– Two dimensional arrays (2D) accessed using two indexes
– Three dimensional arrays (3D) accessed using three indexes
These can be visualized as tables or cubes of elements.
Two Dimensional Arrays
A 2D array can be visualized as a table with rows and columns of elements:
“`
[0,0] [0,1] [0,2]
[1,0] [1,1] [1,2]
[2,0] [2,1] [2,2]
“`
Each element is accessed using two indexes – row number and column number.
For example, arr[1,2] accesses element at row 1 and column 2.
2D arrays are useful for:
– Matrices used in linear algebra
– Representing tables of data
– Pixel values in an image
– Chessboards
– Mazes and grids
Three Dimensional Arrays
A 3D array can be visualized as a cube with elements along three dimensions – depth, rows and columns.
For example, a 3D array with 2 elements along each dimension:
“`
[[0,0] [0,1]] // First depth
[[1,0] [1,1]] // Second depth
“`
Each element is accessed using three indexes – depth, row and column.
3D arrays are useful for:
– 3D game worlds
– MRI and CT scans in medicine
– Modeling 3D objects
– Storing time series of 2D data like video
Declaring Multidimensional Arrays
Multidimensional arrays are declared similar to one-dimensional arrays, but with extra dimensions specified.
For example, to declare a 2D array in C++ with 3 rows and 2 columns:
“`cpp
int arr[3][2];
“`
In Java,
“`java
int[][] arr = new int[3][2];
“`
Accessing elements uses multiple indexes like:
“`
arr[0][0]
arr[2][1]
“`
Higher dimensional arrays add more indexes like:
“`
double[,,] arr3d = new double[10,20,15]; // 3D array in C#
“`
Applications of Arrays
Some common applications and uses of arrays in programming include:
Lists
One-dimensional arrays are commonly used to store lists of elements, like:
– List of names or usernames
– List of scores
– List of ages
– Shopping cart items
Code like below is used to declare, initialize and access lists using arrays:
“`cpp
string names[5] = {“John”, “Mary”, “Tom”, “Sam”, “Bob”};
names[0] = “Jack”; // Modify element
cout << names[2]; // Access element at index 2 ```
Matrices
Matrices are two dimensional arrays commonly used in linear algebra and math. For example:
“`
int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
“`
This stores a 3×3 matrix. Matrix operations like addition, multiplication are implemented using nested for loops iterating over the 2D array.
Lookup Tables
Arrays can be used to efficiently implement lookup tables for searching. For example, the alphabetical order mapping:
“`
index 0 1 2 3 …. 25
char A B C D Z
“`
This array can be used to convert alphabet letters into their position numbers instantly. This technique is used in games and encryption.
Graph Adjacency Matrices
2D arrays are used to represent connectivity in graphs. A value of 1 at matrix[i][j] indicates a connection between nodes i and j. This adjacency matrix is used in graph algorithms.
Image Pixels
2D arrays are ideal for storing the pixel RGB values in images. Each row of the 2D array represents a row of pixels in the image. This makes image processing operations like filters, transformations easier.
Time Series
For storing time series data like audio samples, sensor values, stock prices etc. over time, a 2D array can be used. Each row stores data for a point in time.
Common Array Operations and Algorithms
Some common operations implemented using arrays include:
Traversal
Accessing each element of an array sequentially is done using a for or while loop iterating over the indexes from 0 to array size – 1.
“`cpp
for (int i = 0; i < arr.length; i++) {
// access element arr[i]
}
```
This traverses the array from start to end.
Insertion
Adding a new element inserts it at a specific index, shifting subsequent elements.
“`
Insert 23 at index 5:
[11, 12, 15, 17, 18]
Becomes:
[11, 12, 15, 17, 18, 23]
“`
This involves:
– Creating space by shifting elements by 1 position from index onwards
– Copying new element into created space
Deletion
Removing an element deletes it from a specific index, shifting subsequent elements backwards.
“`
Delete index 2:
[10, 25, 35, 40, 45]
Becomes:
[10, 25, 40, 45]
“`
This involves:
– Shifting elements from index+1 backwards by 1 position
– Reducing length of array by 1
Searching
Searching involves traversing the array linearly comparing each element to the search key. If a match is found, the index is returned.
For example, to search for 35 in the array:
“`
arr = [15, 20, 35, 40, 45]
for (i = 0; i < length; i++) { if (arr[i] == 35) { return i; } } return -1; // 35 not found ``` The optimal search time is O(n) for unsorted arrays.
Sorting
Sorting arranges the elements of an array in specific order like ascending, descending etc.
Some popular sorting algorithms optimized for arrays are:
– Bubble sort
– Insertion sort
– Selection sort
– Quicksort
These involve swapping or rearranging elements by comparing them iteratively.
Reversing
Reversing reverses the order of elements in the array.
For example, for array [1, 2, 3, 4, 5], reversed is [5, 4, 3, 2, 1].
It is implemented by swapping the first and last elements, then 2nd and 2nd last elements and so on. This takes O(n/2) time.
Conclusion
Some key points:
– Arrays allow storing collections of elements of the same type
– Elements are accessed randomly using an index
– One dimensional arrays use a single index subscript
– 2D and multidimensional arrays use two or more subscripts
– Arrays are used to implement lists, matrices, lookup tables, images and much more
– Common operations on arrays include traversal, insertion, deletion etc.
– Knowledge of arrays is required for writing efficient programs and using more complex data structures
Arrays form the basis for other more complex data structures like array lists, vectors and matrices used extensively in software applications and programming solutions. Mastering arrays is essential to build skills in programming.
