What is Difference between one dimensional array and two dimensional?

Answer 1

A matrix (two dimensional array) is a group of lists, or arrays that are organized into one data set. To understand them, first look an example of the standard one dimensional array:

Array "A":

16

8

99

0

5

You can reference any point in the "array" by naming the array and following it with a number representing the position of a piece of data on the list. The first data on the array is represented with a "0", the second with a "1", and so on. For example, A[2] (in bold) represents 99 because it is the third figure of array A. You could imagine the references of the above table as the following:

Array "A":

[0]

[1]

[2]

[3]

[4]

A matrix is a set of arrays. Visualize the following table:

Matrix "B":

16 17 9

8 88 74

99 12 21

0 6 40

5 19 18

There are 3 different arrays in a single data set, "B". In Array A, you could reference any data by naming the point on the list, such as "1" or "3". However, with a matrix, you must give both a row and a column. You can reference data on a matrix in the following format:

MatrixName[row][column]

For example, B[3][2] would represent 40 because it is the it is on the fourth row down and the third column. Remember, matrix references also start at zero, not one! You can reference any of the data on this table with this chart:

Matrix "B":

[0][0] [0][1] [0][2]

[1][0] [1][1] [1][2]

[2][0] [2][1] [2][2]

[3][0] [3][1] [3][2]

[4][0] [4][1] [4][2]

Two-dimensional arrays are used everywhere, but are especially prevalent in computer programming and accounting. If you know any programmers, ask them the last time the last time they used a matrix- I'm sure they'll give you plenty of examples!

Answer 2

Array is a variable which holds the subscript it is similar data type is called array

one dimensional array:It is an variable which holds only one subscript by similar data types

syntax:data type,variable,name [size];

program:#include<stdio.h>

#include<conio.h>

void main()

{

int i;

float x[10],value,total;

clrscr();

printf("enter five real numbers");

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

{

scanf("%f",value);

x[i]=value;

}

total=0.0;

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

total=total+x[i]+x[i];

printf("/n")

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

printf("[%2d]=%5.2f/n",i+1,x[i];

printf("total=%2f/n",total);

}

Answer 3

There is no practical difference. A multi-dimensional array is simply an array where every element is itself an array (an array of arrays). Fixed-size multi-dimensional arrays are always allocated contiguously just as if they were a one-dimensional array, the size of which is the product of its dimensions. Variable size arrays can also be allocated contiguously, however when they are extremely large or if the size in any one dimension is variable, it is often better to split the array into separately allocated arrays and using another array to manage each of the allocations.

Answer 4

If you imagine a standard chessboard, a one-dimensional array representing each of the squares on the board would need to contain 64 elements (numbered 0 to 63).

However, because the board itself is two dimensional, it makes more sense to refer to individual squares by the intersection of the square's row and column. Thus a two dimensional array will contain 8 rows and 8 columns (each of which is numbered 0 to 7).

Another way to look at a two-dimensional array is to imagine that first dimension represents a one-dimensional array of rows while each of these row elements is itself a one-dimensional array of squares, with one square per column. This may seem counter-intuitive at first, but when dealing with dynamic arrays, that may be exactly how the array is allocated. That is, while a static array always occupies contiguous memory locations (regardless of how many dimensions), a dynamic array is often allocated one dimension at a time. Each one-dimensional array will itself be contiguous, but the array as a whole may not be.

However, regardless of how the memory is mapped, the dimensions make it easier to determine which individual element you are accessing. If our board were declared as a one-dimensional array, accessing element[24] doesn't immediately tell us which row or column that element resides in. Whereas element[4][0] tells us exactly which row and column the square is in. These are, in fact, the same square (and therefore the same element), but the second is more intuitive as there's a direct correlation between the array and the object it represents (an 8x8 chessboard).

Arrays aren't restricted to just one or two dimensions. A three-dimensional array might be used to represent a cuboid. For instance, a standard 3x3x3 Rubik's cube might be represented by a three-dimensional array where each dimension has three elements (if we conveniently ignore the fact a Rubik's cube is not a real cube with 27 individual cubes).

We can also go beyond 3-dimensions without the need for a Degree in Theoretical Physics. The trick is to remember that each dimension is itself a one-dimensional array. Therefore a four-dimensional array can be thought of as a one-dimensional array where each element is a three-dimensional array. A five-dimensional array is therefore a one-dimensional array where each element contains a four-dimensional array, and so on.

Once you're familiar with this way of thinking, it no longer matters if the array is allocated contiguously or separately. Every element is addressable by its unique index, whether that index contains one or multiple dimensions.

Dynamic arrays are a bit more difficult to work with, particularly when there are multiple dimensions to consider. However, the simplest way to manage them is by allocating a one-dimensional array for the entire array (multiplying all the dimensions together), and then use a separate array of pointers to divide the larger array into its individual dimensions, and finally maintain a pointer-to-pointer variable to refer to the array of pointers.

So, going back to our chessboard example, if we suppose the chessboard is not restricted to 8x8 squares, a static array would be no use as it couldn't cater fora 9x9 board. Se we need a dynamic array. We begin by declaring a pointer-to-pointer and allocate a 9-element array of pointers to it. We then allocate an 81-element array to the first pointer. The other 8 pointers are then assigned an address within the 81-element array, such that each is offset by 9 elements from the previous element.

Now we can access the array itself using the pointer-to-pointer, just as if it were a static array. If the pointer-to-pointer were named board, then board[1][2] would access the square in the second row, third column. This works because the [1] refers to the second pointer in the pointer array (which points to the second row in the array), while the [2] refers to the third element in that row. The language is such that we need not concern ourselves with the fact an array of pointers exists but, without it, we'd not be able to access the array multi-dimensionally.

An alternative way to allocate the array would be to allocate individual one-dimensional arrays to each pointer in the pointer array (where each array represents a row on the board). However, because this would require 9 separate allocations, the creation of the array as a whole takes much longer than it would with the single allocation. In addition, releasing the array is much simplified as we only have to release the entire array (pointed to by the first element in the pointer array), and then release the pointer array itself. Using individual allocations would mean releasing each pointer in the pointer array before release the pointer array itself.

Regardless of how the array is allocated, accessing the individual elements is achieved in the same way, via the pointer-to-pointer. It does not matter if the array resides in contiguous memory or not -- the pointer array takes care of all that for us automatically.

Moving onto three dimensions and beyond is only complicated by the fact the pointer-to-pointer requires an extra level of indirection for each additional dimension. That is, a pointer-to-pointer-to-pointer is required for a three-dimensional array, which points to an array of pointer-to-pointer, each of which points to an array of pointer, each of which points to an appropriate offset within the actual array.

Why bother with just two? Think about 27+(just to begin with) different dimensions & inter Universal expansionsional change regarding 'PURE ENERGY the form of Dark Matter & it's direct correlation with it's inter-actional Relationship to CREATION & ALL Eternity should be able to do that over lunch:)) 'Doc' is just fine:)

Pick your Wavelength & the several Frequencies contained therein..........& GO FOR IT. You have talent.

Answer 5

The short answer is that a single dimension array has just one dimension while a multi-dimensional array has 2 or more dimensions.

A single-dimension array can be thought of as being a row of numbered pigeon holes, where the first pigeon hole is numbered 0. This is what is meant by a zero-based index.

A multi-dimensional array can be thought of as being an array of arrays. For example, a two-dimensional array is a one-dimensional array of one-dimensional arrays. A chessboard is an example of a two dimensional array, where each square is identified by an unique row and column identifier. Two-dimensional arrays are often used to represent tables and matrices.

A three-dimensional array can be thought of as being a 3D cuboid, where each cell can be identified by three dimensions (such as width, height and depth). However, it is more accurate to state that a three dimensional array is a one-dimensional array of two-dimensional arrays, because this then makes it easier to comprehend four dimensional arrays (a one-dimensional array of three dimensional arrays) and so on. Another way to think of four dimensional arrays is as a row of cuboids. A five-dimensional array is therefore a table of cuboids, while a six-dimensional array becomes a cuboid of cuboids.

Regardless of the number of dimensions, each element in an array is accessed through the array indices, such that there is one index per dimension. However, since each element within a dimension has the same number of elements, you can also use pointer arithmetic to navigate the array. Indeed, that is exactly what happens Behind the Scenes -- the index values are just sugar-coating to make arrays easier to work with.

Answer 6

For the computer, not much. Every array, no matter how many dimensions it has, is stored as a one-dimensional array. However, the benefit is that it allows the data to be sorted in a way that is possibly clearer for the programmer or user. All the computer does is multiply all those indexes by the bit sizes of their blocks, and add them together to find the address of the data it needs. So the trade-off of multidimensional arrays is slowing down the program a bit to make it's working a bit simpler for the user/programmer.

Answer 7

The number of dimensions.

Example:

int single[21];

int matrix[10][10], cube[2][2][2];

Answer 8

two dimension array used to enter the two field of data that is in row size and column size

Answer 9

Number of dimensions.