Searched

What is Data Structure?

Personal

Data structure in my personal point of view is that it is a way of storing data into a computer for it to be used efficiently. It is in a systematic and in a logarithmic way of running. It is used in running a computer-type data base and run machines with its capabilities. Data structure is implemented by a certain language for a computer to understand. There are a lot of types of data structures, each with different way of running data and storing data. In computer science, data structures are an important way of organizing information in a computer. There are many different data structures that programmers use to organize data in computers. Some data structures are similar to the tree diagram because they are good for representing relationships between data. Other structures are good for ordering data in a particular way like the list of employees. Each data structure has unique properties that make it well suited to give a certain view of the data. A data structure can be viewed as an interface between two functions or as an implementation of methods to access storage that is organized according to the associated data type.

Other details about data structure with its references

data structure in computer science is a way of storing data in a computer so that it can be used efficiently. It is an organization of mathematical and logical concepts of data. Often a carefully chosen data structure will allow the most efficient algorithm to be used. The choice of the data structure often begins from the choice of an abstract data type. A well-designed data structure allows a variety of critical operations to be performed, using as few resources, both execution time and memory space, as possible. Data structures are implemented by a programming language as data types and the references and operations they provide.

http://en.wikipedia.org/wiki/Data_structure

An organization of information, usually in memory, for better algorithm efficiency, such as queue, stack, linked list, heap, dictionary, and tree, or conceptual unity, such as the name and address of a person. It may include redundant information, such as length of the list or number of nodes in a subtree.

http://www.itl.nist.gov/div897/sqg/dads/HTML/datastructur.html

In programming, the term data structure refers to a scheme for organizing related pieces of information. The basic types of data structures include: files, lists, arrays, records, trees, tables. Each of these basic structures has many variations and allows different operations to be performed on the data.

http://www.webopedia.com/TERM/D/data_structure.html

Computers can store and process vast amounts of data. Formal data structures enable a programmer to mentally structure large amounts of data into conceptually manageable relationships.

Sometimes we use data structures to allow us to do more: for example, to accomplish fast searching or sorting of data. Other times, we use data structures so that we can do less: for example, the concept of the stack is a limited form of a more general data structure. These limitations provide us with guarantees that allow us to reason about our programs more easily. Data structures also provide guarantees about algorithmic complexity — choosing an appropriate data structure for a job is crucial for writing good software.

Because data structures are higher-level abstractions, they present to us operations on groups of data, such as adding an item to a list, or looking up the highest-priority item in a queue. When a data structure provides operations, we can call the data structure an abstract data type (sometimes abbreviated as ADT). Abstract data types can minimize dependencies in your code, which is important when your code needs to be changed. Because you are abstracted away from lower-level details, some of the higher-level commonalities one data structure shares with a different data structure can be used to replace one with the other.

http://en.wikibooks.org/wiki/Data_Structures/Introduction\

A data structure is a specialized format for organizing and storing data. General data structure types include the array, the file, the record, the table, the tree, and so on. Any data structure is designed to organize data to suit a specific purpose so that it can be accessed and worked with in appropriate ways. In computer programming, a data structure may be selected or designed to store data for the purpose of working on it with various algorithms.

http://searchsqlserver.techtarget.com/sDefinition/0,,sid87_gci804744,00.html

A collection of data components that are constructed in a regular and characteristic way.

http://www.answers.com/topic/data-structure

This insight has given rise to many formalized design methods and programming languages in which data structures, rather than algorithms, are the key organizing factor. Most languages feature some sort of module system, allowing data structures to be safely reused in different applications by hiding their verified implementation details behind controlled interfaces. Object-oriented programming languages such as C++ and Java in particular use classes for this purpose.

http://en.wikipedia.org/wiki/Data_structure

In computer science, data structures are an important way of organizing information in a computer. There are many different data structures that programmers use to organize data in computers. Some data structures are similar to the tree diagram because they are good for representing relationships between data. Other structures are good for ordering data in a particular way like the list of employees. Each data structure has unique properties that make it well suited to give a certain view of the data.

http://courses.cs.vt.edu/~csonline/DataStructures/Lessons/Introduction/index.html

The fundamental building blocks of most data structures are arrays, records, discriminated unions, and references. For example, the nullable reference, a reference which can be null, is a combination of references and discriminated unions, and the simplest linked data structure, the linked list, is built from records and nullable references.Data structures represent implementations or interfaces: A data structure can be viewed as an interface between two functions or as an implementation of methods to access storage that is organized according to the associated data type.

http://en.wikipedia.org/wiki/Data_structure

Other types of Data Structure

Vlists

In computer science, the VList is a persistent data structure designed by Phil Bagwell in 2002 that combines the fast indexing of arrays with the easy extension of cons-based (or singly-linked) linked lists.[1]

Like arrays, VLists have constant-time lookup on average and are highly compact, requiring only O(log n) storage for pointers, allowing them to take advantage of locality of reference. Like singly-linked or cons-based lists, they are persistent, and elements can be added to or removed from the front in constant time. Length can also be found in O(log n) time.

The primary operations of a VList are:

* Locate the kth element (O(1) average, O(log n) worst-case)
* Add an element to the front of the VList (O(1) average, with an occasional allocation)
* Obtain a new array beginning at the second element of an old array (O(1))
* Compute the length of the list (O(log n))

The primary advantages VLists have over arrays are that they are threadsafe (when locking is used; see the discussion page) and that different updated versions of the VList automatically share structure. Because VLists are immutable, they are most useful in functional programming languages, where their efficiency allows a purely functional implementation of data structures traditionally thought to require mutable arrays, such as hash tables.

The underlying structure of a VList can be seen as a singly-linked list of arrays whose sizes decrease geometrically; in its simplest form, the first contains the first half of the elements in the list, the next the first half of the remainder, and so on. Each of these blocks stores some information such as its size and a pointer to the next.

The average constant-time indexing operation comes directly from this structure; given a random valid index, we simply observe the size of the blocks and follow pointers until we reach the one it should be in. The chance is 1/2 that it falls in the first block and we need not follow any pointers; the chance is 1/4 we have to follow only one, and so on, so that the expected number of pointers.

Any particular reference to a VList is actually a pair indicating the position of its first element in the data structure described above. The base part indicates which of the arrays its first element falls in, while the offset part indicates its index in that array. This makes it easy to "remove" an element from the front of the list; we simply increase the offset, or increase the base and set the offset to zero if the offset goes out of range. If a particular reference is the last to leave a block, the block will be garbage-collected if such facilities are available, or otherwise must be freed explicitly.

Because the lists are constructed incrementally, the first array in the array list may not contain twice as many values as the next one, although the rest do; this does not significantly impact indexing performance. We nevertheless allocate this much space for the first array, so that if we add more elements to the front of the list in the future we can simply add them to this list and update the size. If the array fills up, we create a new array, twice as large again as this one, and link it to the old first array.

VList may be modified to support the implementation of a growable array. In the application of a growable array, immutability is no longer required. Instead of growing at the beginning of the list, the ordering interpretation is reversed to allow growing at the end of the array.

http://en.wikipedia.org/wiki/VList

Zipper

Zipper is a purely functional data structure used in functional programming to solve some problems in a way that uses notions like “context” and “hole”. It is related to the generalization of the notion of “derivative” (for types). The zipper was described by Gerard Huet in 1997. It has some conceptual similarity to the gap buffer technique sometimes used with arrays.

Zippers are multidimensional in the sense that they can be used as lists or trees by placing additional restrictions upon them. Such derived data structures are usually referred to by saying a tree with zipper or a list with zipper to give the image that the structure is a tree or a list, with a zip slider attach to it as an afterthought.

While zipper is a functional structure and is often used from within a functional language equipped with extensive type checking, there is no reason why it would not be suitable for use with many procedural languages as well. Many procedural languages even support functional programming to some degree. A minimal list with zipper example is described below in Python. The example is only used to present the core idea and is not provided as a guide for actually implementing a zipper.

cursor = [ [0,1,2], 3, [4,5,6,7,8,9] ]

The structure is named cursor because its value is a list with focus set on value 3. Technically it is (at top level) a list with exactly three values([0,1,2], 3 and [4,5,6,7,8,9]). This list starts with a list of elements ([0,1,2]) that precede the element with current focus, then as the second element it contains the element with focus (3) and finally it contains another list ([4,5,6,7,8,9]) with the elements that follow the element with current focus.

http://en.wikipedia.org/wiki/Zipper_(data_structure)

Deque

In computer science theory, a deque (short for double-ended queue—usually pronounced deck) is an abstract list type data structure, also called a head-tail linked list, for which elements can only be added to or removed from the front (head) or back (tail).

Deque is sometimes written dequeue, but this use is generally deprecated in technical literature or technical writing because dequeue is also a verb meaning "to remove from a queue". Nevertheless, several libraries and some writers, such as Aho, Hopcroft, and Ullman in their textbook Data Structures and Algorithms, spell it dequeue. DEQ and DQ are also used.

This differs from the queue abstract data type or First-In-First-Out List (FIFO), where elements can only be added to one end and removed from the other. This general data class has some possible sub-types:

* An input-restricted deque is one where deletion can be made from both ends, but input can only be made at one end.

* An output-restricted deque is one where input can be made at both ends, but output can be made from one end only.

Both the basic and most common list types in computing, the queues and stacks can be considered specializations of deques, and can be implemented using deques.

http://en.wikipedia.org/wiki/Deque