|
|
| Line 1: |
Line 1: |
| {{Use dmy dates|date=June 2013}}
| | It is very common to have a dental emergency -- a fractured tooth, an abscess, or severe pain when chewing. Over-the-counter pain medication is just masking the problem. Seeing an emergency dentist is critical to getting the source of the problem diagnosed and corrected as soon as possible.<br><br>Here are some common dental emergencies:<br>Toothache: The most common dental emergency. This generally means a badly decayed tooth. As the pain affects the tooth's nerve, treatment involves gently removing any debris lodged in the cavity being careful not to poke deep as this will cause severe pain if the nerve is touched. Next rinse vigorously with warm water. Then soak a small piece of cotton in oil of cloves and insert it in the cavity. This will give temporary relief until a dentist can be reached.<br><br>At times the pain may have a more obscure location such as decay under an old filling. As this can be only corrected by a dentist there are two things you can do to help the pain. Administer a pain pill (aspirin or some other analgesic) internally or dissolve a tablet in a half glass (4 oz) of warm water holding it in the mouth for several minutes before spitting it out. DO NOT PLACE A WHOLE TABLET OR ANY PART OF IT IN THE TOOTH OR AGAINST THE SOFT GUM TISSUE AS IT WILL RESULT IN A NASTY BURN.<br><br>Swollen Jaw: This may be caused by several conditions the most probable being an abscessed tooth. In any case the treatment should be to reduce pain and swelling. An ice pack held on the outside of the jaw, (ten minutes on and ten minutes off) will take care of both. If this does not control the pain, an analgesic tablet can be given every four hours.<br><br>Other Oral Injuries: Broken teeth, cut lips, bitten tongue or lips if severe means a trip to a dentist as soon as possible. In the mean time rinse the mouth with warm water and place cold compression the face opposite the injury. If there is a lot of bleeding, apply direct pressure to the bleeding area. If bleeding does not stop get patient to the emergency room of a hospital as stitches may be necessary.<br><br>Prolonged Bleeding Following Extraction: Place a gauze pad or better still a moistened tea bag over the socket and have the patient bite down gently on it for 30 to 45 minutes. The tannic acid in the tea seeps into the tissues and often helps stop the bleeding. If bleeding continues after two hours, call the dentist or take patient to the emergency room of the nearest hospital.<br><br>Broken Jaw: If you suspect the patient's jaw is broken, bring the upper and lower teeth together. Put a necktie, handkerchief or towel under the chin, tying it over the head to immobilize the jaw until you can get the patient to a dentist or the emergency room of a hospital.<br><br>Painful Erupting Tooth: In young children teething pain can come from a loose baby tooth or from an erupting permanent tooth. Some relief can be given by crushing a little ice and wrapping it in gauze or a clean piece of cloth and putting it directly on the tooth or gum tissue where it hurts. The numbing effect of the cold, along with an appropriate dose of aspirin, usually provides temporary relief.<br><br>In young adults, an erupting 3rd molar (Wisdom tooth), especially if it is impacted, can cause the jaw to swell and be quite painful. Often the gum around the tooth will show signs of infection. Temporary relief can be had by giving aspirin or some other painkiller and by dissolving an aspirin in half a glass of warm water and holding this solution in the mouth over the sore gum. AGAIN DO NOT PLACE A TABLET DIRECTLY OVER THE GUM OR CHEEK OR USE THE ASPIRIN SOLUTION ANY STRONGER THAN RECOMMENDED TO PREVENT BURNING THE TISSUE. The swelling of the jaw can be reduced by using an ice pack on the outside of the face at intervals of ten minutes on and ten minutes off.<br><br>If you loved this article and you also would like to acquire more info pertaining to [http://www.youtube.com/watch?v=90z1mmiwNS8 Dentists in DC] i implore you to visit our own web-page. |
| {{Distinguish|Array data type}}
| |
| {{Refimprove|date=September 2008}}
| |
| | |
| The simplest type of data structure is a linear array. This is also called one dimensional array. In [[computer science]], an '''array data structure''' or simply an '''array''' is a [[data structure]] consisting of a collection of ''elements'' ([[value (computer science)|values]] or [[variable (programming)|variables]]), each identified by at least one ''array index'' or ''key''. An array is stored so that the position of each element can be computed from its index [[tuple]] by a mathematical formula.<ref>{{cite web|url=http://www.nist.gov/dads/HTML/array.html|title=array|last=Black|first=Paul E.|date=13 November 2008|work=[[Dictionary of Algorithms and Data Structures]]|publisher=[[National Institute of Standards and Technology]]|accessdate=22 August 2010}}</ref><ref name="andres">{{cite arXiv |eprint=1008.2909 |author1=Bjoern Andres |author2=Ullrich Koethe |author3=Thorben Kroeger |author4=Hamprecht |title=Runtime-Flexible Multi-dimensional Arrays and Views for C++98 and C++0x |class=cs.DS |year=2010}}</ref><ref name="garcia">{{Cite journal|last1=Garcia|first1=Ronald |first2=Andrew |last2=Lumsdaine|year=2005|title=MultiArray: a C++ library for generic programming with arrays|journal=Software: Practice and Experience|volume=35|issue=2|pages=159–188|issn=0038-0644|doi=10.1002/spe.630}}</ref>
| |
| | |
| For example, an array of 10 integer variables, with indices 0 through 9, may be stored as 10 [[Word (data type)|words]] at memory addresses 2000, 2004, 2008, … 2036, so that the element with index ''i'' has the address 2000 + 4 × ''i''.<ref>David R. Richardson (2002), The Book on Data Structures. iUniverse, 112 pages. ISBN 0-595-24039-9, ISBN 978-0-595-24039-5.</ref>
| |
| | |
| Because the mathematical concept of a [[matrix (mathematics)|matrix]] can be represented as a two-dimensional grid, two-dimensional arrays are also sometimes called matrices. In some cases the term "vector" is used in computing to refer to an array, although [[tuple]]s rather than [[vector space|vectors]] are more correctly the mathematical equivalent. Arrays are often used to implement [[table (information)|table]]s, especially [[lookup table]]s; the word ''table'' is sometimes used as a synonym of ''array''.
| |
| | |
| Arrays are among the oldest and most important data structures, and are used by almost every program. They are also used to implement many other data structures, such as [[list (computing)|list]]s and [[string (computer science)|string]]s. They effectively exploit the addressing logic of computers. In most modern computers and many [[external storage]] devices, the memory is a one-dimensional array of words, whose indices are their addresses. [[Central processing unit|Processors]], especially [[vector processor]]s, are often optimized for array operations.
| |
| | |
| Arrays are useful mostly because the element indices can be computed at [[Run time (program lifecycle phase)|run time]]. Among other things, this feature allows a single iterative [[statement (programming)|statement]] to process arbitrarily many elements of an array. For that reason, the elements of an array data structure are required to have the same size and should use the same data representation. The set of valid index tuples and the addresses of the elements (and hence the element addressing formula) are usually,<ref name="garcia" /><ref name="veldhuizen">T. Veldhuizen. Arrays in Blitz++. In Proc. of the 2nd Int. Conf. on Scientific Computing in Object-Oriented Parallel Environments (ISCOPE), LNCS 1505, pages 223-220. Springer, 1998.</ref> but not always,<ref name="andres" /> fixed while the array is in use.
| |
| | |
| The term ''array'' is often used to mean [[array data type]], a kind of [[data type]] provided by most [[high-level programming language]]s that consists of a collection of values or variables that can be selected by one or more indices computed at run-time. Array types are often implemented by array structures; however, in some languages they may be implemented by [[hash table]]s, [[linked list]]s, [[search tree]]s, or other data structures. | |
| | |
| The term is also used, especially in the description of [[algorithm]]s, to mean [[associative array]] or "abstract array", a [[theoretical computer science]] model (an [[abstract data type]] or ADT) intended to capture the essential properties of arrays.
| |
| | |
| ==History==
| |
| The first digital computers used machine-language programming to set up and access array structures for data tables, vector and matrix computations, and for many other purposes. [[John von Neumann|Von Neumann]] wrote the first array-sorting program ([[merge sort]]) in 1945, during the building of the [[EDVAC|first stored-program computer]].<ref>Donald Knuth, ''The Art of Computer Programming'', vol. 3. Addison-Wesley</ref><sup>p. 159</sup> Array indexing was originally done by [[self-modifying code]], and later using [[index register]]s and [[Addressing mode|indirect addressing]]. Some mainframes designed in the 1960s, such as the [[Burroughs large systems|Burroughs B5000]] and its successors, used [[memory segmentation]] to perform index-bounds checking in hardware.<ref>{{citation|title=Capability-based Computer Systems|first=Henry M.|last=Levy|publisher=Digital Press|year=1984|isbn=9780932376220|page=22}}.</ref>
| |
| | |
| Assembly languages generally have no special support for arrays, other than what the machine itself provides. The earliest high-level programming languages, including [[Fortran|FORTRAN]] (1957), [[COBOL]] (1960), and [[ALGOL|ALGOL 60]] (1960), had support for multi-dimensional arrays, and so has [[C (programming language)|C]] (1972). In [[C++]] (1983), class templates exist for multi-dimensional arrays whose dimension is fixed at runtime<ref name="garcia" /><ref name="veldhuizen" /> as well as for runtime-flexible arrays.<ref name="andres" />
| |
| | |
| {{Expand section|date=May 2009}}
| |
| | |
| ==Applications==
| |
| Arrays are used to implement mathematical [[coordinate vector|vectors]] and [[matrix (mathematics)|matrices]], as well as other kinds of rectangular tables. Many [[database]]s, small and large, consist of (or include) one-dimensional arrays whose elements are [[record (computer science)|record]]s.
| |
| | |
| Arrays are used to implement other data structures, such as [[heap (data structure)|heaps]], [[hash table]]s, [[double-ended queue|deque]]s, [[queue (data structure)|queue]]s, [[stack (data structure)|stacks]], [[String (computer science)|strings]], and [[VList]]s.
| |
| | |
| One or more large arrays are sometimes used to emulate in-program [[dynamic memory allocation]], particularly [[memory pool]] allocation. Historically, this has sometimes been the only way to allocate "dynamic memory" portably.
| |
| | |
| Arrays can be used to determine partial or complete [[control flow]] in programs, as a compact alternative to (otherwise repetitive) multiple <code>IF</code> statements. They are known in this context as [[control table]]s and are used in conjunction with a purpose built interpreter whose [[control flow]] is altered according to values contained in the array. The array may contain [[subroutine]] [[Pointer (computer programming)|pointers]] (or relative subroutine numbers that can be acted upon by [[Switch statement|SWITCH]] statements) that direct the path of the execution.
| |
| | |
| ==Array element identifier and addressing formulas==
| |
| | |
| When data objects are stored in an array, individual objects are selected by an index that is usually a non-negative [[scalar (computing)|scalar]] [[integer]]. Indices are also called subscripts. An index ''maps'' the array value to a stored object.
| |
| | |
| There are three ways in which the elements of an array can be indexed:
| |
| | |
| * '''0''' (''[[Zero-based numbering|zero-based indexing]]''): The first element of the array is indexed by subscript of 0.<ref>{{cite web
| |
| | accessdate = 8 April 2011
| |
| | location = http://www.configure-all.com/
| |
| | publisher = Computer Programming Web programming Tips
| |
| | title = Array Code Examples - PHP Array Functions - PHP code
| |
| | quote = In most computer languages array index (counting) starts from 0, not from 1. Index of the first element of the array is 0, index of the second element of the array is 1, and so on. In array of names below you can see indexes and values.
| |
| | url = http://www.configure-all.com/arrays.php}}</ref>
| |
| * '''1''' (''one-based indexing''): The first element of the array is indexed by subscript of 1.<ref>{{cite web
| |
| | accessdate = 8 April 2011
| |
| | location = http://www.modula2.org/tutor/index.php
| |
| | work = Modula-2 Tutorial
| |
| | title = Chapter 6 - Arrays, Types, and Constants
| |
| | quote = The names of the twelve variables are given by Automobiles[1], Automobiles[2], ... Automobiles[12]. The variable name is "Automobiles" and the array subscripts are the numbers 1 through 12. [i.e. in Modula-2, the index starts by one!]
| |
| | url = http://www.modula2.org/tutor/chapter6.php}}</ref>
| |
| * '''n''' (''n-based indexing''): The base index of an array can be freely chosen. Usually programming languages allowing ''n-based indexing'' also allow negative index values and other [[scalar (computing)|scalar]] data types like [[Enumerated type|enumerations]], or [[Character (computing)|characters]] may be used as an array index.
| |
| | |
| Arrays can have multiple dimensions, thus it is not uncommon to access an array using multiple indices. For example a two-dimensional array <code>A</code> with three rows and four columns might provide access to the element at the 2nd row and 4th column by the expression <code>A[1, 3]</code> (in a [[row major]] language) or <code>A[3, 1]</code> (in a [[column major]] language) in the case of a zero-based indexing system. Thus two indices are used for a two-dimensional array, three for a three-dimensional array, and ''n'' for an ''n''-dimensional array.
| |
| | |
| The number of indices needed to specify an element is called the dimension, dimensionality, or [[rank (computer programming)|rank]] of the array.
| |
| | |
| In standard arrays, each index is restricted to a certain range of consecutive integers (or consecutive values of some [[enumerated type]]), and the address of an element is computed by a "linear" formula on the indices.
| |
| | |
| ===One-dimensional arrays===
| |
| A one-dimensional array (or single dimension array) is a type of linear array. Accessing its elements involves a single subscript which can either represent a row or column index.
| |
| | |
| As an example consider the C declaration <code>int anArrayName[10];</code>
| |
| | |
| Syntax : datatype anArrayname[sizeofArray];
| |
| | |
| In the given example the array can contain 10 elements of any value available to the <code>int</code> type. In C, the array element indices are 0-9 inclusive in this case. For example, the expressions <code>anArrayName[0]</code> and <code>anArrayName[9]</code> are the first and last elements respectively.
| |
| | |
| For a vector with linear addressing, the element with index ''i'' is located at the address ''B'' + ''c'' · ''i'', where ''B'' is a fixed ''base address'' and ''c'' a fixed constant, sometimes called the ''address increment'' or ''stride''.
| |
| | |
| If the valid element indices begin at 0, the constant ''B'' is simply the address of the first element of the array. For this reason, the [[C (programming language)|C programming language]] specifies that array indices always begin at 0; and many programmers will call that element "[[Zero-based numbering|zeroth]]" rather than "first".
| |
| | |
| However, one can choose the index of the first element by an appropriate choice of the base address ''B''. For example, if the array has five elements, indexed 1 through 5, and the base address ''B'' is replaced by ''B'' + 30''c'', then the indices of those same elements will be 31 to 35. If the numbering does not start at 0, the constant ''B'' may not be the address of any element.
| |
| | |
| ===Multidimensional arrays===
| |
| For a two-dimensional array, the element with indices ''i'',''j'' would have address ''B'' + ''c'' · ''i'' + ''d'' · ''j'', where the coefficients ''c'' and ''d'' are the ''row'' and ''column address increments'', respectively.
| |
| | |
| More generally, in a ''k''-dimensional array, the address of an element with indices ''i''<sub>1</sub>, ''i''<sub>2</sub>, …, ''i''<sub>''k''</sub> is
| |
| :''B'' + ''c''<sub>1</sub> · ''i''<sub>1</sub> + ''c''<sub>2</sub> · ''i''<sub>2</sub> + … + ''c''<sub>''k''</sub> · ''i''<sub>''k''</sub>.
| |
| | |
| For example: int a[3][2];
| |
| | |
| This means that array a has 3 rows and 2 columns, and the array is of integer type. Here we can store 6 elements they are stored linearly but starting from first row linear then continuing with second row. The above array will be stored as a<sub>11</sub>, a<sub>12</sub>, a<sub>13</sub>, a<sub>21</sub>, a<sub>22</sub>, a<sub>23</sub>.
| |
| | |
| This formula requires only ''k'' multiplications and ''k'' additions, for any array that can fit in memory. Moreover, if any coefficient is a fixed power of 2, the multiplication can be replaced by [[bitwise operation|bit shifting]].
| |
| | |
| The coefficients ''c''<sub>''k''</sub> must be chosen so that every valid index tuple maps to the address of a distinct element.
| |
| | |
| If the minimum legal value for every index is 0, then ''B'' is the address of the element whose indices are all zero. As in the one-dimensional case, the element indices may be changed by changing the base address ''B''. Thus, if a two-dimensional array has rows and columns indexed from 1 to 10 and 1 to 20, respectively, then replacing ''B'' by ''B'' + ''c''<sub>1</sub> - − 3 ''c''<sub>1</sub> will cause them to be renumbered from 0 through 9 and 4 through 23, respectively. Taking advantage of this feature, some languages (like FORTRAN 77) specify that array indices begin at 1, as in mathematical tradition; while other languages (like Fortran 90, Pascal and Algol) let the user choose the minimum value for each index.
| |
| | |
| ===Dope vectors===
| |
| The addressing formula is completely defined by the dimension ''d'', the base address ''B'', and the increments ''c''<sub>1</sub>, ''c''<sub>2</sub>, …, ''c''<sub>''k''</sub>. It is often useful to pack these parameters into a record called the array's ''descriptor'' or ''stride vector'' or ''[[dope vector]]''.<ref name="andres" /><ref name="garcia" /> The size of each element, and the minimum and maximum values allowed for each index may also be included in the dope vector. The dope vector is a complete [[handle (computing)|handle]] for the array, and is a convenient way to pass arrays as arguments to [[subroutine|procedures]]. Many useful [[array slicing]] operations (such as selecting a sub-array, swapping indices, or reversing the direction of the indices) can be performed very efficiently by manipulating the dope vector.<ref name="andres" /> | |
| | |
| ===Compact layouts===
| |
| Often the coefficients are chosen so that the elements occupy a contiguous area of memory. However, that is not necessary. Even if arrays are always created with contiguous elements, some array slicing operations may create non-contiguous sub-arrays from them.
| |
| | |
| There are two systematic compact layouts for a two-dimensional array. For example, consider the matrix
| |
| :<math>\mathbf{A} =
| |
| \begin{bmatrix}
| |
| 1 & 2 & 3 \\
| |
| 4 & 5 & 6 \\
| |
| 7 & 8 & 9
| |
| \end{bmatrix}.
| |
| </math> | |
| In the [[row-major order]] layout (adopted by C for statically declared arrays), the elements in each row are stored in consecutive positions and all of the elements of a row have a lower address than any of the elements of a consecutive row:
| |
| {| border=1
| |
| |-
| |
| | 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9
| |
| |}
| |
| In [[Row-major order|column-major order]] (traditionally used by Fortran), the elements in each column are consecutive in memory and all of the elements of a column have a lower address than any of the elements of a consecutive column: | |
| {| border=1
| |
| |-
| |
| | 1 || 4 || 7 || 2 || 5 || 8 || 3 || 6 || 9
| |
| |}
| |
| For arrays with three or more indices, "row major order" puts in consecutive positions any two elements whose index tuples differ only by one in the ''last'' index. "Column major order" is analogous with respect to the ''first'' index.
| |
| | |
| In systems which use [[processor cache]] or [[virtual memory]], scanning an array is much faster if successive elements are stored in consecutive positions in memory, rather than sparsely scattered. Many algorithms that use multidimensional arrays will scan them in a predictable order. A programmer (or a sophisticated compiler) may use this information to choose between row- or column-major layout for each array. For example, when computing the product ''A''·''B'' of two matrices, it would be best to have ''A'' stored in row-major order, and ''B'' in column-major order.
| |
| | |
| ===Array resizing===
| |
| {{Main|Dynamic array}}
| |
| | |
| Static arrays have a size that is fixed when they are created and consequently do not allow elements to be inserted or removed. However, by allocating a new array and copying the contents of the old array to it, it is possible to effectively implement a ''dynamic'' version of an array; see [[dynamic array]]. If this operation is done infrequently, insertions at the end of the array require only amortized constant time.
| |
| | |
| Some array data structures do not reallocate storage, but do store a count of the number of elements of the array in use, called the count or size. This effectively makes the array a [[dynamic array]] with a fixed maximum size or capacity; [[Pascal string]]s are examples of this.
| |
| | |
| ===Non-linear formulas===
| |
| More complicated (non-linear) formulas are occasionally used. For a compact two-dimensional [[triangular array]], for instance, the addressing formula is a polynomial of degree 2.
| |
| | |
| ==Efficiency==
| |
| Both ''store'' and ''select'' take (deterministic worst case) [[constant time]]. Arrays take linear ([[Big-O notation|O]](''n'')) space in the number of elements ''n'' that they hold.
| |
| | |
| In an array with element size ''k'' and on a machine with a cache line size of B bytes, iterating through an array of ''n'' elements requires the minimum of ceiling(''nk''/B) cache misses, because its elements occupy contiguous memory locations. This is roughly a factor of B/''k'' better than the number of cache misses needed to access ''n'' elements at random memory locations. As a consequence, sequential iteration over an array is noticeably faster in practice than iteration over many other data structures, a property called [[locality of reference]] (this does ''not'' mean however, that using a [[Perfect hash function|perfect hash]] or [[hash function#Trivial hash function|trivial hash]] within the same (local) array, will not be even faster - and achievable in [[constant time]]). Libraries provide low-level optimized facilities for copying ranges of memory (such as [[String.h|memcpy]]) which can be used to move [[contiguous]] blocks of array elements significantly faster than can be achieved through individual element access. The speedup of such optimized routines varies by array element size, architecture, and implementation. | |
| | |
| Memory-wise, arrays are compact data structures with no per-element [[Computational overhead|overhead]]. There may be a per-array overhead, e.g. to store index bounds, but this is language-dependent. It can also happen that elements stored in an array require ''less'' memory than the same elements stored in individual variables, because several array elements can be stored in a single [[Word (data type)|word]]; such arrays are often called ''packed'' arrays. An extreme (but commonly used) case is the [[bit array]], where every bit represents a single element. A single [[octet (computing)|octet]] can thus hold up to 256 different combinations of up to 8 different conditions, in the most compact form.
| |
| | |
| Array accesses with statically predictable access patterns are a major source of [[data parallelism]].
| |
| | |
| ===Efficiency comparison with other data structures===
| |
| {{List data structure comparison}}
| |
| [[Dynamic array|Growable array]]s are similar to arrays but add the ability to insert and delete elements; adding and deleting at the end is particularly efficient. However, they reserve linear ([[Big-O notation#Family of Bachmann–Landau notations|Θ]](''n'')) additional storage, whereas arrays do not reserve additional storage.
| |
| | |
| [[Associative array]]s provide a mechanism for array-like functionality without huge storage overheads when the index values are sparse. For example, an array that contains values only at indexes 1 and 2 billion may benefit from using such a structure. Specialized associative arrays with integer keys include [[Radix tree|Patricia trie]]s, [[Judy array]]s, and [[van Emde Boas tree]]s.
| |
| | |
| [[Self-balancing binary search tree|Balanced trees]] require O(log ''n'') time for indexed access, but also permit inserting or deleting elements in O(log ''n'') time,<ref>[http://www.chiark.greenend.org.uk/~sgtatham/algorithms/cbtree.html Counted B-Tree]</ref> whereas growable arrays require linear (Θ(''n'')) time to insert or delete elements at an arbitrary position.
| |
| | |
| [[Linked list]]s allow constant time removal and insertion in the middle but take linear time for indexed access. Their memory use is typically worse than arrays, but is still linear.
| |
| | |
| [[Image:Array of array storage.svg|120px|left|A two-dimensional array stored as a one-dimensional array of one-dimensional arrays (rows).]]
| |
| An [[Iliffe vector]] is an alternative to a multidimensional array structure. It uses a one-dimensional array of [[reference (computer science)|references]] to arrays of one dimension less. For two dimensions, in particular, this alternative structure would be a vector of pointers to vectors, one for each row. Thus an element in row ''i'' and column ''j'' of an array ''A'' would be accessed by double indexing (''A''[''i''][''j''] in typical notation). This alternative structure allows ''ragged'' or ''jagged'' arrays, where each row may have a different size — or, in general, where the valid range of each index depends on the values of all preceding indices. It also saves one multiplication (by the column address increment) replacing it by a bit shift (to index the vector of row pointers) and one extra memory access (fetching the row address), which may be worthwhile in some architectures.<br clear=left />
| |
| | |
| ==Meaning of dimension==
| |
| The dimension of an array is the number of indices needed to select an element. Thus, if the array is seen as a function on a set of possible index combinations, it is the dimension of the space of which its domain is a discrete subset. Thus a one-dimensional array is a list of data, a two-dimensional array a rectangle of data, a three-dimensional array a block of data, etc.
| |
| | |
| This should not be confused with the dimension of the set of all matrices with a given domain, that is, the number of elements in the array. For example, an array with 5 rows and 4 columns is two-dimensional, but such matrices form a 20-dimensional space. Similarly, a three-dimensional vector can be represented by a one-dimensional array of size three.
| |
| | |
| ==See also==
| |
| *[[Dynamic array]]
| |
| *[[Parallel array]]
| |
| *[[Variable-length array]]
| |
| *[[Bit array]]
| |
| *[[Array slicing]]
| |
| *[[Offset (computer science)]]
| |
| *[[Row-major order]]
| |
| *[[Stride of an array]]
| |
| | |
| ==References==
| |
| {{Reflist}}
| |
| | |
| ==External links==
| |
| {{Wiktionary|array}}
| |
| {{Wikibooks|Data Structures/Arrays}}
| |
| {{Commons category|Array data structure}}
| |
| | |
| {{Data structures}}
| |
| | |
| {{DEFAULTSORT:Array Data Structure}}
| |
| [[Category:Arrays|*]]
| |
| [[Category:Data structures]]
| |