text:
Array data structure
From Wikipedia, the free encyclopedia
Jump to navigation Jump to search
This article is about the byte-layout-level structure. For the abstract data type, see Array data type. For other uses, see Array.
This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (September 2008) (Learn how and when to remove this template message)
In computer science, an array data structure, or simply an array, is a data structure consisting of a collection of elements (values or variables), each identified by at least one array index or key. An array is stored such that the position of each element can be computed from its index tuple by a mathematical formula.[1][2][3] The simplest type of data structure is a linear array, also called one-dimensional array.
For example, an array of 10 32-bit integer variables, with indices 0 through 9, may be stored as 10 words at memory addresses 2000, 2004, 2008, ... 2036, so that the element with index i has the address 2000 + 4 × i.[4]
The memory address of the first element of an array is called first address or foundation address.
Because the mathematical concept of a 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 tuples rather than vectors are the more mathematically correct equivalent. Tables are often implemented in the form of arrays, especially lookup tables; 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 lists and strings. 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. Processors, especially vector processors, are often optimized for array operations.
Arrays are useful mostly because the element indices can be computed at run time. Among other things, this feature allows a single iterative 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,[3][5] but not always,[2] 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 languages 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 tables, linked lists, search trees, or other data structures.
The term is also used, especially in the description of algorithms, 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. Arrays have better cache locality as compared to linked lists.
Contents
[hide]
1 History
2 Applications
3 Element identifier and addressing formulas
3.1 One-dimensional arrays
3.2 Multidimensional arrays
3.3 Dope vectors
3.4 Compact layouts
3.5 Resizing
3.6 Non-linear formulas
4 Efficiency
4.1 Comparison with other data structures
5 Dimension
6 See also
7 References
History[edit]
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 wrote the first array-sorting program (merge sort) in 1945, during the building of the first stored-program computer.[6]p. 159 Array indexing was originally done by self-modifying code, and later using index registers and indirect addressing. Some mainframes designed in the 1960s, such as the Burroughs B5000 and its successors, used memory segmentation to perform index-bounds checking in hardware.[7]
Assembly languages generally have no special support for arrays, other than what the machine itself provides. The earliest high-level programming languages, including FORTRAN (1957), Lisp (1958), COBOL (1960), and ALGOL 60 (1960), had support for multi-dimensional arrays, and so has C (1972). In C++ (1983), class templates exist for multi-dimensional arrays whose dimension is fixed at runtime[3][5] as well as for runtime-flexible arrays.[2]
This section needs expansion. You can help by adding to it. (May 2009)
Applications[edit]
Arrays are used to implement mathematical vectors and matrices, as well as other kinds of rectangular tables. Many databases, small and large, consist of (or include) one-dimensional arrays whose elements are records.
Arrays are used to implement other data structures, such as lists, heaps, hash tables, deques, queues, stacks, strings, and VLists. Array-based implementations of other data structures are frequently simple and space-efficient (implicit data structures), requiring little space overhead, but may have poor space complexity, particularly when modified, compared to tree-based data structures (compare a sorted array to a search tree).
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 IF statements. They are known in this context as control tables 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 pointers (or relative subroutine numbers that can be acted upon by SWITCH statements) that direct the path of the execution.
Element identifier and addressing formulas[edit]
When data objects are stored in an array, individual objects are selected by an index that is usually a non-negative scalar integer. Indexes 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 indexing): The first element of the array is indexed by subscript of 0.[8]
1 (one-based indexing): The first element of the array is indexed by subscript of 1.[9]
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 data types like enumerations, or 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 A with three rows and four columns might provide access to the element at the 2nd row and 4th column by the expression A[1, 3] 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 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[edit]
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 int anArrayName[10];
Syntax : datatype anArrayname[sizeofArray];
In the given example the array can contain 10 elements of any value available to the int type. In C, the array element indices are 0-9 inclusive in this case. For example, the expressions anArrayName[0] and anArrayName[9] 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 specifies that array indices always begin at 0; and many programmers will call that element "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 + 30c, 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[edit]
For a multidimensional 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 i1, i2, ..., ik is
B + c1 · i1 + c2 · i2 + ... + ck · ik.
For example: int a[2][3];
This means that array a has 2 rows and 3 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 a11, a12, a13, a21, a22, a23.
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 bit shifting.
The coefficients ck 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 + c1 - − 3 c1 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[edit]
The addressing formula is completely defined by the dimension d, the base address B, and the increments c1, c2, ..., ck. It is often useful to pack these parameters into a record called the array's descriptor or stride vector or dope vector.[2][3] 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 for the array, and is a convenient way to pass arrays as arguments to 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.[2]
Compact layouts[edit]
Main article: Row- and column-major order
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.
Illustration of row- and column-major order
There are two systematic compact layouts for a two-dimensional array. For example, consider the matrix
A = [ 1 2 3 4 5 6 7 8 9 ] . {\displaystyle \mathbf {A} ={\begin{bmatrix}1&2&3\\4&5&6\\7&8&9\end{bmatrix}}.}
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:
1 2 3 4 5 6 7 8 9
In 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:
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.
Resizing[edit]
Main article: 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 strings are examples of this.
Non-linear formulas[edit]
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[edit]
Both store and select take (deterministic worst case) constant time. Arrays take linear (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 or 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 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 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; 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 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.
Comparison with other data structures[edit]
Comparison of list data structures
Linked list
Array
Dynamic array
Balanced tree
Random access list
Hashed array tree
Indexing Θ(n) Θ(1) Θ(1) Θ(log n) Θ(log n)[10] Θ(1)
Insert/delete at beginning Θ(1) N/A Θ(n) Θ(log n) Θ(1) Θ(n)
Insert/delete at end Θ(1) when last element is known;
Θ(n) when last element is unknown N/A Θ(1) amortized Θ(log n) Θ(log n) updating Θ(1) amortized
Insert/delete in middle search time + Θ(1)[11][12][13] N/A Θ(n) Θ(log n) Θ(log n) updating Θ(n)
Wasted space (average) Θ(n) 0 Θ(n)[14] Θ(n) Θ(n) Θ(√n)
Growable arrays 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 (Θ(n)) additional storage, whereas arrays do not reserve additional storage.
Associative arrays 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 Patricia tries, Judy arrays, and van Emde Boas trees.
Balanced trees require O(log n) time for indexed access, but also permit inserting or deleting elements in O(log n) time,[15] whereas growable arrays require linear (Θ(n)) time to insert or delete elements at an arbitrary position.
Linked lists 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.
An Iliffe vector is an alternative to a multidimensional array structure. It uses a one-dimensional array of 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 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.
Dimension[edit]
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[edit]
Computer programming portal
Dynamic array
Parallel array
Variable-length array
Bit array
Array slicing
Offset (computer science)
Row- and column-major order
Stride of an array
References[edit]
Look up array in Wiktionary, the free dictionary.
Wikibooks has a book on the topic of: Data Structures/Arrays
Wikimedia Commons has media related to Array data structure.
Jump up ^ Black, Paul E. (13 November 2008). "array". Dictionary of Algorithms and Data Structures. National Institute of Standards and Technology. Retrieved 22 August 2010.
^ Jump up to: a b c d e Bjoern Andres; Ullrich Koethe; Thorben Kroeger; Hamprecht (2010). "Runtime-Flexible Multi-dimensional Arrays and Views for C++98 and C++0x". arXiv:1008.2909  [cs.DS].
^ Jump up to: a b c d Garcia, Ronald; Lumsdaine, Andrew (2005). "MultiArray: a C++ library for generic programming with arrays". Software: Practice and Experience. 35 (2): 159–188. doi:10.1002/spe.630. ISSN 0038-0644.
Jump up ^ David R. Richardson (2002), The Book on Data Structures. iUniverse, 112 pages. ISBN 0-595-24039-9, ISBN 978-0-595-24039-5.
^ Jump up to: a b Veldhuizen, Todd L. (December 1998). Arrays in Blitz++ (PDF). Computing in Object-Oriented Parallel Environments. Lecture Notes in Computer Science. 1505. Springer Berlin Heidelberg. pp. 223–230. doi:10.1007/3-540-49372-7_24. ISBN 978-3-540-65387-5.
Jump up ^ Donald Knuth, The Art of Computer Programming, vol. 3. Addison-Wesley
Jump up ^ Levy, Henry M. (1984), Capability-based Computer Systems, Digital Press, p. 22, ISBN 9780932376220 .
Jump up ^ "Array Code Examples - PHP Array Functions - PHP code". http://www.configure-all.com/: Computer Programming Web programming Tips. Retrieved 8 April 2011. 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.
Jump up ^ "Chapter 6 - Arrays, Types, and Constants". Modula-2 Tutorial. http://www.modula2.org/tutor/index.php. Retrieved 8 April 2011. 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!]
Jump up ^ Chris Okasaki (1995). "Purely Functional Random-Access Lists". Proceedings of the Seventh International Conference on Functional Programming Languages and Computer Architecture: 86–95. doi:10.1145/224164.224187.
Jump up ^ Gerald Kruse. CS 240 Lecture Notes: Linked Lists Plus: Complexity Trade-offs. Juniata College. Spring 2008.
Jump up ^ Day 1 Keynote - Bjarne Stroustrup: C++11 Style at GoingNative 2012 on channel9.msdn.com from minute 45 or foil 44
Jump up ^ Number crunching: Why you should never, ever, EVER use linked-list in your code again at kjellkod.wordpress.com
Jump up ^ Brodnik, Andrej; Carlsson, Svante; Sedgewick, Robert; Munro, JI; Demaine, ED (1999), Resizable Arrays in Optimal Time and Space (Technical Report CS-99-09) (PDF), Department of Computer Science, University of Waterloo
Jump up ^ "Counted B-Trees".
hide
v
t
e
Data structures
Types
Collection
Container
Abstract
Associative array
Multimap
List
Stack
Queue
Double-ended queue
Priority queue
Double-ended priority queue
Set
Multiset
Disjoint-set
Arrays
Bit array
Circular buffer
Dynamic array
Hash table
Hashed array tree
Sparse matrix
Linked
Association list
Linked list
Skip list
Unrolled linked list
XOR linked list
Trees
B-tree
Binary search tree
AA tree
AVL tree
Red–black tree
Self-balancing tree
Splay tree
Heap
Binary heap
Binomial heap
Fibonacci heap
R-tree
R* tree
R+ tree
Hilbert R-tree
Trie
Hash tree
Graphs
Binary decision diagram
Directed acyclic graph
Directed acyclic word graph
List of data structures
Authority control
GND: 4376624-9
Retrieved from "https://en.wikipedia.org/w/index.php?title=Array_data_structure&oldid=845424223"
Categories:
Arrays
Hidden categories:
Use dmy dates from June 2013
Articles needing additional references from September 2008
All articles needing additional references
Articles to be expanded from May 2009
All articles to be expanded
Articles using small message boxes
Wikipedia articles with GND identifiers
Navigation menu
Personal tools
Not logged in
Talk
Contributions
Create account
Log in
Namespaces
Article
Talk
Variants
Views
Read
Edit
View history
More
Search
Navigation
Main page
Contents
Featured content
Current events
Random article
Donate to Wikipedia
Wikipedia store
Interaction
Help
About Wikipedia
Community portal
Recent changes
Contact page
Tools
What links here
Related changes
Upload file
Special pages
Permanent link
Page information
Wikidata item
Cite this page
Print/export
Create a book
Download as PDF
Printable version
In other projects
Wikimedia Commons
Languages
العربية
Azərbaycanca
Bân-lâm-gú
Български
Català
Čeština
Dansk
Deutsch
Eesti
Ελληνικά
Español
Esperanto
فارسی
Français
한국어
Bahasa Indonesia
Interlingua
Íslenska
Italiano
עברית
Қазақша
Latviešu
Lumbaart
Magyar
മലയാളം
Монгол
Nederlands
日本語
Norsk
Олык марий
Polski
Português
Русский
Simple English
Slovenčina
Slovenščina
Српски / srpski
Srpskohrvatski / српскохрватски
Suomi
Svenska
Tagalog
தமிழ்
ไทย
Türkçe
Українська
Tiếng Việt
中文
38 more
Edit links
This page was last edited on 11 June 2018, at 18:14 (UTC).
Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization.
Privacy policy
About Wikipedia
Disclaimers
Contact Wikipedia
Developers
Cookie statement
Mobile view
Enable previews

values: mw-page-base noprint

values: mw-head-base noprint

values: firstHeading firstHeading en

values: siteSub noprint

values: mw-jump-link #mw-head

values: mw-jump-link #p-search

attrs: href class title

values:
/wiki/Array_(disambiguation)
mw-redirect
Array (disambiguation)

values:
note
hatnote navigation-not-searchable

attrs: alt src width height srcset data-file-width data-file-height

attrs: href class

value: td

value: b

values: Help:Introduction to referencing with Wiki Markup/1

value: span

value: i

value: small

values: plainlinks metadata ambox ambox-content ambox-Refimprove

values:
/wiki/Variable_(programming)
mw-redirect
Variable (programming)

values:
/wiki/Word_(data_type)
mw-redirect
Word (data type)

values:
/wiki/List_(computing)
mw-redirect
List (computing)

values:
/wiki/Statement_(programming)
mw-redirect
Statement (programming)

values: plainlinks metadata ambox mbox-small-left ambox-content

values:
/wiki/Queue_(data_structure)
mw-redirect
Queue (data structure)

values:
/wiki/Stack_(data_structure)
mw-redirect
Stack (data structure)

values:
/wiki/Dynamic_memory_allocation
mw-redirect
Dynamic memory allocation

values: Edit section: Element identifier and addressing formulas

values:
/wiki/Scalar_(computing)
mw-redirect
Scalar (computing)

values: vertical-align: -4.005ex; width:17.749ex; height:9.176ex;

values:
/wiki/Processor_cache
mw-redirect
Processor cache

values:
/wiki/Pascal_string
mw-redirect
Pascal string

values:
/wiki/Constant_time
mw-redirect
Constant time

values:
/wiki/Big-O_notation
mw-redirect
Big-O notation

values:
/wiki/Contiguous_data_storage
mw-redirect
Contiguous data storage

values:
/wiki/Computational_overhead
mw-redirect
Computational overhead

values: Edit section: Comparison with other data structures

values: Random access list (page does not exist)

values: background: #ececec; color: #2C2C2C; vertical-align: middle; font-size: smaller; text-align: center;

values: A two-dimensional array stored as a one-dimensional array of one-dimensional arrays (rows).

values: display:table-cell;padding:0.2em 0.2em 0.2em 0.3em;vertical-align:middle

values: margin:0.5em 0 0.5em 1em;border:solid #aaa 1px

values: -moz-column-width: 20em; -webkit-column-width: 20em; column-width: 20em;

values: Dictionary of Algorithms and Data Structures

values: National Institute of Standards and Technology

values:
nofollow
external text
//arxiv.org/abs/1008.2909

values:
nofollow
external text
//arxiv.org/archive/cs.DS

values:
nofollow
external text
//doi.org/10.1002%2Fspe.630

values:
nofollow
external text
//www.worldcat.org/issn/0038-0644

values:
nofollow
external text
http://www.configure-all.com/arrays.php

values:
nofollow
http://www.configure-all.com/
external free

values:
nofollow
external free
http://www.modula2.org/tutor/index.php

values:
nofollow
external text
//doi.org/10.1145%2F224164.224187

values: -moz-column-width: 30em; -webkit-column-width: 30em; column-width: 30em; list-style-type: decimal;

values: Deterministic acyclic finite state automaton

values: nowraplinks hlist collapsible autocollapse navbox-inner mw-collapsible mw-made-collapsible

values:
nofollow
external text
https://d-nb.info/gnd/4376624-9

values: Category:Articles needing additional references from September 2008

values: Category:All articles needing additional references

values: Category:Articles to be expanded from May 2009

values: Category:Articles using small message boxes

values: Category:Wikipedia articles with GND identifiers

values: Discussion about edits from this IP address [ctrl-alt-n]

values: A list of edits made from this IP address [ctrl-alt-y]

values: You are encouraged to create an account and log in; however, it is not mandatory

values: You're encouraged to log in; however, it's not mandatory. [ctrl-alt-o]

values:
/wiki/Array_data_structure
View the content page [ctrl-alt-c]
c

values: Discussion about the content page [ctrl-alt-t]

values: p-namespaces navigation vectorTabs p-namespaces-label

values:
p-variants
navigation
vectorMenu emptyPortlet
p-variants-label

values: Past revisions of this page [ctrl-alt-h]

values: p-views navigation vectorTabs p-views-label

values:
p-cactions
navigation
vectorMenu emptyPortlet
p-cactions-label

values:
mw-wiki-logo
/wiki/Main_Page
Visit the main page

values:
/wiki/Main_Page
Visit the main page [ctrl-alt-z]
z

values: Featured content – the best of Wikipedia

values: Find background information on current events

values:
/wiki/Special:Random
Load a random article [ctrl-alt-x]
x

values: portal navigation p-navigation p-navigation-label

values: Guidance on how to use and edit Wikipedia

values: About the project, what you can do, where to find things

values: A list of recent changes in the wiki [ctrl-alt-r]

values: portal navigation p-interaction p-interaction-label

values: List of all English Wikipedia pages containing links to this page [ctrl-alt-j]

values: Recent changes in pages linked from this page [ctrl-alt-k]

values:
/wiki/Wikipedia:File_Upload_Wizard
Upload files [ctrl-alt-u]
u

values: A list of all special pages [ctrl-alt-q]

values: Permanent link to this revision of the page

values: Link to connected data repository item [ctrl-alt-g]

values: Printable version of this page [ctrl-alt-p]

values: portal navigation p-wikibase-otherprojects p-wikibase-otherprojects-label

values: مصفوفة (حوسبة) – Arabic

values:
https://az.wikipedia.org/wiki/Massiv
Massiv – Azerbaijani
az
az
interlanguage-link-target

values:
interlanguage-link interwiki-az
display: none;

values:
interlanguage-link interwiki-zh-min-nan
display: none;

values: Масив (програмиране) – Bulgarian

values:
interlanguage-link interwiki-bg
display: none;

values:
interlanguage-link interwiki-ca
display: none;

values:
interlanguage-link interwiki-cs
display: none;

values:
https://da.wikipedia.org/wiki/Array
Array – Danish
da
da
interlanguage-link-target

values:
interlanguage-link interwiki-da
display: none;

values:
interlanguage-link interwiki-et
display: none;

values: Πίνακας (δομή δεδομένων) – Greek

values:
interlanguage-link interwiki-el
display: none;

values:
interlanguage-link interwiki-eo
display: none;

values: آرایه (ساختار داده) – Persian

values:
interlanguage-link interwiki-fa
display: none;

values:
interlanguage-link interwiki-ko
display: none;

values:
https://id.wikipedia.org/wiki/Larik
Larik – Indonesian
id
id
interlanguage-link-target

values:
interlanguage-link interwiki-ia
display: none;

values:
interlanguage-link interwiki-is
display: none;

values:
https://it.wikipedia.org/wiki/Array
Array – Italian
it
it
interlanguage-link-target

values:
interlanguage-link interwiki-it
display: none;

values: מערך (מבנה נתונים) – Hebrew

values:
interlanguage-link interwiki-he
display: none;

values:
interlanguage-link interwiki-kk
display: none;

values:
interlanguage-link interwiki-lv
display: none;

values:
https://lmo.wikipedia.org/wiki/Array
Array – Lombard
lmo
lmo
interlanguage-link-target

values:
interlanguage-link interwiki-lmo
display: none;

values: അടുക്ക് (ദത്തസങ്കേതം) – Malayalam

values:
interlanguage-link interwiki-mn
display: none;

values:
https://nl.wikipedia.org/wiki/Array
Array – Dutch
nl
nl
interlanguage-link-target

values:
interlanguage-link interwiki-mhr
display: none;

values: Массив (программирование) – Russian

values:
interlanguage-link interwiki-sk
display: none;

values:
interlanguage-link interwiki-sl
display: none;

values: Низ (структура података) – Serbian

values:
interlanguage-link interwiki-sr
display: none;

values: Niz (struktura podataka) – Serbo-Croatian

values:
interlanguage-link interwiki-sh
display: none;

values: அணி (கணினியியல்) – Tamil

values:
interlanguage-link interwiki-ta
display: none;

values: แถวลำดับ – Thai

values:
interlanguage-link interwiki-th
display: none;

values: Масив (структура даних) – Ukrainian

values:
interlanguage-link interwiki-uk
display: none;

values: All languages (initial selection from common choices by you and others)

values: /static/images/wikimedia-button-1.5x.png 1.5x, /static/images/wikimedia-button-2x.png 2x

values: /static/images/poweredby_mediawiki_132x47.png 1.5x, /static/images/poweredby_mediawiki_176x62.png 2x

values:
suggestions
display: none; font-size: 13px;

values: mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Array_data_structure rootpage-Array_data_structure skin-vector action-view